C++-------指针

把地址当做数值

在 C++ 中，指针本质上就是存储内存地址的变量。每个变量在内存中都有一个唯一的地址，通过取地址运算符 & 可以获取变量的地址，这个地址本质上是一个整数（在 32 位系统中是 32 位整数，64 位系统中是 64 位整数）。例如：

int num = 10;
int* ptr = #  // ptr 存储了 num 的内存地址

这里，&num 获取 num 的地址并赋值给指针 ptr，我们就可以把这个地址当成一个数值来操作，不过通常不会像普通整数那样随意运算，更多是为了实现指针相关的语义，比如指针偏移。

声明指针变量

指针变量的声明需要指定它指向的数据类型，语法形式为 数据类型* 指针变量名。例如：

int* p1;  // 指向 int 类型数据的指针
double* p2;  // 指向 double 类型数据的指针
char* p3;  // 指向 char 类型数据的指针

声明后指针变量需要初始化，指向合法的内存地址，否则可能出现悬空指针（野指针）的情况，引发未定义行为。初始化方式可以是指向已声明变量的地址，或者动态分配内存：

int num = 5;
int* p = #int* q = new int;  // 动态分配一个 int 大小的内存，q 指向这块内存
*q = 10;
delete q;  // 使用完后释放内存

基本的指针运算

• 指针偏移：指针加上或减去一个整数 n，实际偏移的字节数是 n 乘以指针所指向数据类型的大小。例如：

int arr[5] = {1, 2, 3, 4, 5};
int* p = arr;  // p 指向数组首元素
p++;  // p 指向数组第二个元素，偏移了 sizeof(int) 个字节

• 指针相减：两个指向同一数组元素的指针相减，结果是它们之间间隔的元素个数，而不是字节数。

int* p1 = &arr[1];
int* p2 = &arr[3];
int diff = p2 - p1;  // diff 为 2

指向结构和对象的指针

对于结构体和类对象，同样可以用指针来指向它们：

struct Point {int x;int y;
};Point p = {1, 2};
Point* ptr = &p;  // 指向结构体对象的指针// 通过指针访问结构体成员
ptr->x = 3;
ptr->y = 4; 

对于类也是类似：

class MyClass {
public:void print() {cout << "Hello" << endl;}
};MyClass obj;
MyClass* pObj = &obj;
pObj->print();

关键字 this

this 是 C++ 类中的一个关键字，它是一个指向当前对象的指针。当类的成员函数被调用时，this 指针会自动传递给函数，指向调用该函数的对象实例。例如：

class Rectangle {
public:int width, height;Rectangle(int w, int h) {this->width = w;this->height = h;}
};

这里 this 用来区分形参 w、h 和类成员变量 width、height，明确表示是给类成员变量赋值。

特殊指针 NULL

NULL 是一个预定义的宏，在 C++ 中它表示空指针，即不指向任何有效内存地址的指针。通常用于指针初始化，或者判断指针是否有效：

int* p = NULL;
if (p == NULL) {// 指针未指向有效地址
}

在现代 C++ 中，更推荐使用 nullptr，它是类型安全的空指针常量，避免了一些因 NULL 类型不明确带来的潜在错误 。

指针和引用调用

• 指针调用：通过指针访问对象或变量，可以修改所指向内存的内容。例如：

void increment(int* num) {(*num)++;
}int main() {int n = 5;increment(&n);cout << n << endl;  // 输出 6return 0;
}

• 引用调用：引用是对象的别名，声明形式为 数据类型& 引用名 = 对象名 。引用必须初始化，之后对引用的操作等同于对它绑定对象的操作：

void increment(int& num) {num++;
}int main() {int n = 5;increment(n);cout << n << endl;  // 输出 6
}

引用相较于指针，语法上更加简洁直观，且不需要像指针那样担心空指针的问题，但引用一旦绑定就不能再重新绑定到其他对象。

C++中this关键字的作用是什么？

在C++中，this关键字主要有以下几个重要作用：

1. 区分成员变量和局部变量（或参数）
   • 在类的成员函数中，如果局部变量（包括函数参数）与成员变量同名，使用this指针可以明确地访问成员变量。例如：

class MyClass {
private:int value;
public:MyClass(int value) {// 使用this指针来区分参数value和成员变量valuethis->value = value;}void printValue() {std::cout << this->value << std::endl;}
};

- 这里，`this->value` 表示类的成员变量`value`，而单独的`value`在构造函数的参数列表中是指传入的参数。通过`this`指针，可以确保将参数正确地赋值给成员变量，并在其他成员函数中正确地访问成员变量。

2. 在对象链式调用中返回对象本身
   • this指针可以用于返回对象本身，使得对象的方法调用可以像链条一样连续进行。例如，考虑一个表示数学向量的类，我们可以定义加法操作，使得多个向量相加的操作可以链式调用：

class Vector {
private:double x;double y;
public:Vector(double x, double y) : x(x), y(y) {}Vector& add(const Vector& other) {this->x += other.x;this->y += other.y;// 返回对象本身，以便进行链式调用return *this;}void print() {std::cout << "(" << x << ", " << y << ")" << std::endl;}
};

- 可以这样使用：

int main() {Vector v1(1.0, 2.0);Vector v2(3.0, 4.0);Vector v3(5.0, 6.0);v1.add(v2).add(v3).print();return 0;
}

- 在`add`函数中，`return *this`返回了当前对象的引用，这样就可以继续调用该对象的其他成员函数，实现链式操作，使得代码更加简洁和易读。

3. 作为函数参数传递当前对象的地址
   • 在某些情况下，可能需要将当前对象的地址传递给其他函数。this指针本质上是指向当前对象的指针，所以可以直接将this作为参数传递。例如，当需要将对象插入到一个数据结构（如链表）中时，可能需要传递对象的指针：

class Node {
private:int data;Node* next;
public:Node(int data) : data(data), next(NULL) {}void insertIntoList(Node*& head) {// 一些插入节点到链表的逻辑，可能需要传递当前对象的指针if (head == NULL) {head = this;} else {// 其他插入逻辑}}
};

- 这里`this`作为当前对象（`Node`）的指针被用于在链表中插入节点的操作，帮助实现对象与其他数据结构之间的交互。

总之，this关键字在C++中是一个非常重要的工具，用于在类的内部明确地引用当前对象，提供了对成员变量和成员函数的正确访问方式，同时也支持了一些高级的编程技巧，如链式调用等。