c++ 指针的用法详解

C++中的指针是一个非常重要的概念,指针变量用于存储其他变量的内存地址。通过指针,程序可以直接访问和操作内存,提高了程序的灵活性和效率。以下是关于C++指针用法的详解。

1. 指针的基本概念

  • 定义:指针是一个变量,其值为另一个变量的地址。
  • 类型 :指针的类型决定了它所指向的变量类型,例如 int*char*double* 等。

2. 指针的声明和初始化

cpp 复制代码
int main() {
    int var = 10;         // 定义一个整数变量
    int* ptr = &var;     // 声明指针并初始化为var的地址

    std::cout << "var: " << var << std::endl;         // 输出 10
    std::cout << "ptr: " << ptr << std::endl;         // 输出 var 的地址
    std::cout << "*ptr: " << *ptr << std::endl;       // 输出指针所指向的值,即 10

    return 0;
}

3. 指针的基本操作

  • 获取地址 :使用取地址运算符 & 获取变量的地址。
  • 解引用 :使用解引用运算符 * 访问指针所指向的值。
示例:
cpp 复制代码
int main() {
    int a = 5;
    int* p = &a;            // p指向a的地址
    std::cout << "a: " << a << std::endl; // 输出: 5
    std::cout << "p: " << p << std::endl; // 输出: a的地址
    std::cout << "*p: " << *p << std::endl; // 输出: 5

    *p = 20; // 通过指针修改a的值
    std::cout << "a after change: " << a << std::endl; // 输出: 20

    return 0;
}

4. 指针的数组

指针可以与数组结合使用,实际上,数组名本身就可以视为指向数组首元素的指针。

示例:
cpp 复制代码
int main() {
    int arr[] = {1, 2, 3, 4, 5};
    int* ptr = arr; // 指向数组的首元素

    for (int i = 0; i < 5; ++i) {
        std::cout << "arr[" << i << "] = " << *(ptr + i) << std::endl; // 使用指针访问数组元素
    }

    return 0;
}

5. 指针与动态内存分配

使用指针可以动态分配内存,使用 new 操作符分配内存,使用 delete 操作符释放内存。

示例:
cpp 复制代码
int main() {
    int* p = new int;  // 动态分配一个整数
    *p = 30;           // 赋值
    std::cout << "*p: " << *p << std::endl; // 输出: 30

    delete p;         // 释放内存

    // 动态分配数组
    int* arr = new int[5]; // 动态分配一个整数数组
    for(int i = 0; i < 5; ++i) {
        arr[i] = i * 10; // 赋值
    }

    for(int i = 0; i < 5; ++i) {
        std::cout << arr[i] << " "; // 输出: 0 10 20 30 40
    }
    std::cout << std::endl;

    delete[] arr; // 释放数组内存

    return 0;
}

6. 指针的指针

指针变量也可以存储指针的地址,这称为指向指针的指针。

示例:
cpp 复制代码
int main() {
    int var = 10;
    int* ptr = &var;        // 指向var的指针
    int** ptr2 = &ptr;     // 指向指针ptr的指针

    std::cout << "var: " << var << std::endl;       // 输出: 10
    std::cout << "*ptr: " << *ptr << std::endl;     // 输出: 10
    std::cout << "**ptr2: " << **ptr2 << std::endl; // 输出: 10继续深入了解指针的用法,以下是一些更复杂的指针应用和相关概念。

### 7. 常量指针与指向常量的指针

- **常量指针**:指针本身可以被修改,但指针指向的内容不能被修改。
- **指向常量的指针**:指针不能修改,但指针指向的内容可以被修改。

#### 示例:

```cpp
void modifyValue(int* ptr) {
    *ptr = 20; // 可以修改指针指向的值
}

void tryToModifyValue(const int* ptr) {
    // *ptr = 20; // 错误,不能修改常量指针所指向的值
}

int main() {
    int var = 10;
    int* p = &var;        // 普通指针
    const int* cp = &var; // 指向常量的指针

    modifyValue(p);
    std::cout << "var after modifyValue: " << var << std::endl; // 输出: 20

    // tryToModifyValue(cp); // 这行代码会导致编译错误

    return 0;
}

8. 引用与指针的区别

引用是C++中提供的另一种间接访问变量的方法,以下是指针和引用之间的不同点:

  • 引用必须在声明时初始化,而指针可以在任何时候初始化。
  • 引用不能为nullptr,而指针可以。
  • 引用在使用时更简单,不需要解引用操作符*
示例:
cpp 复制代码
void modify(int& ref) { // 引用参数
    ref = 30; // 直接修改
}

int main() {
    int var = 10;
    modify(var); // 传递变量的引用
    std::cout << "var after modify: " << var << std::endl; // 输出: 30
    return 0;
}

9. 函数指针

函数指针是一种指向函数的指针,可以用来实现回调函数等。

示例:
cpp 复制代码
#include <iostream>

void greet() {
    std::cout << "Hello, World!" << std::endl;
}

void execute(void (*func)()) { // 函数指针参数
    func(); // 调用传入的函数
}

int main() {
    void (*funcPtr)() = greet; // 声明函数指针并初始化
    execute(funcPtr);          // 传递函数指针
    return 0;
}

10. 指针与结构体

指针可以用来访问结构体的成员,C++中使用 -> 运算符来访问指针所指向的结构体的成员。

示例:
cpp 复制代码
#include <iostream>

struct Point {
    int x;
    int y;
};

int main() {
    Point p1 = {10, 20};
    Point* ptr = &p1; // 指向结构体的指针

    std::cout << "Point p1: (" << ptr->x << ", " << ptr->y << ")" << std::endl; // 输出: (10, 20)

    ptr->x = 30; // 通过指针修改结构体成员
    std::cout << "Modified Point p1: (" << p1.x << ", " << p1.y << ")" << std::endl; // 输出: (30, 20)

    return 0;
}

11. 智能指针

C++11引入了智能指针(如 std::unique_ptrstd::shared_ptr),它们可以自动管理动态分配的内存,避免内存泄漏。

示例:
cpp 复制代码
#include <iostream>
#include <memory> // 引入智能指针

int main() {
    std::unique_ptr<int> uptr(new int(5)); // 创建一个unique_ptr
    std::cout << "Value: " << *uptr << std::endl; // 输出: 5

    // std::shared_ptr<int> sptr(new int(10)); // 创建一个shared_ptr
    // std::cout << "Value: " << *sptr << std::endl; // 输出: 10

    // 在作用域结束时,unique_ptr会自动释放内存
    return 0;
}

12. 总结

指针在C++编程中非常重要,它们提供了灵活性和强大功能,但也需要小心使用,避免内存泄漏和指针悬挂等问题。通过使用智能指针,可以大大简化内存管理。

相关推荐
一点媛艺2 小时前
Kotlin函数由易到难
开发语言·python·kotlin
姑苏风2 小时前
《Kotlin实战》-附录
android·开发语言·kotlin
奋斗的小花生3 小时前
c++ 多态性
开发语言·c++
魔道不误砍柴功3 小时前
Java 中如何巧妙应用 Function 让方法复用性更强
java·开发语言·python
闲晨3 小时前
C++ 继承:代码传承的魔法棒,开启奇幻编程之旅
java·c语言·开发语言·c++·经验分享
老猿讲编程3 小时前
一个例子来说明Ada语言的实时性支持
开发语言·ada
UestcXiye4 小时前
《TCP/IP网络编程》学习笔记 | Chapter 3:地址族与数据序列
c++·计算机网络·ip·tcp
Chrikk4 小时前
Go-性能调优实战案例
开发语言·后端·golang
幼儿园老大*4 小时前
Go的环境搭建以及GoLand安装教程
开发语言·经验分享·后端·golang·go
canyuemanyue4 小时前
go语言连续监控事件并回调处理
开发语言·后端·golang