c++基础：指针

指针

是用来存储内存地址的变量。通过指针，您可以访问和操作内存中的数据。以下是有关C++指针的一些

基本概念和用法：

1：声明和初始化指针

要声明一个指针，您需要指定指针的数据类型，然后使用*操作符来声明指针变量。指针变量可以存储其他变量的地址。

int* ptr; // 声明一个整数指针
double* dblPtr; // 声明一个双精度浮点数指针


1
2
3
4

2：要初始化指针，可以将其设置为其他变量的地址或使用动态内存分配函数（如new）来分配内存并获取其地址。

指针定义的时候前面会有一个类型，确定类型后不能在进行更改了类型了

int *int_ptr {};//声明一个初始化为空的指针
char *char_ptr {nullptr}//声明一个初始化为空的指针,意思为指针不在指向任何地址
1
2

int x = 10;
int* ptr = &x; // 将ptr指向变量x的地址

int* dynamicPtr = new int; // 使用new分配内存
1
2
3
4

3：解引用指针

解引用指针意味着访问指针所指向的内存地址处的值。要解引用指针，使用*操作符。

int x = 10;
int* ptr = &x;

// 解引用ptr以获取x的值
int value = *ptr;

value 现在为10

//通过指针修改变量的值
*ptr = 100
此时的x就为：100

1
2
3
4
5
6
7
8
9
10
11
12

4：指针算术

指针可以进行算术操作，例如增加、减少，以在内存中移动到其他位置。

int arr[] = {1, 2, 3, 4, 5};
int* ptr = arr; // 指向数组的第一个元素

// 使用指针进行数组遍历
for (int i = 0; i < 5; i++) {
    std::cout << *ptr << " ";
    ptr++; // 移动指针到下一个元素
}
1
2
3
4
5
6
7
8

5：空指针

空指针是指不指向任何有效内存地址的指针，通常表示为nullptr。

int* nullPtr = nullptr; // 声明一个空指针
1

6：指针和数组

C++中，数组名本质上是一个指向数组第一个元素的指针。这意味着可以使用指针来访问数组元素。

int arr[] = {1, 2, 3, 4, 5};
int* ptr = arr; // 数组名是指向arr[0]的指针

// 使用指针访问数组元素
std::cout << *ptr << std::endl; // 输出1  
ptr++; // 移动指针到下一个元素
std::cout << *ptr << std::endl; // 输出2
//或者  
std::cout << *(ptr+1) << std::endl; //输出3


//使用下标方式指定

int arr [] {1, 2, 3, 4, 5};
int *ptr  {arr}; // 数组名是指向arr[0]的指针

cout << ptr[0] << std::endl;// 输出1
cout << ptr[1] << std::endl;// 输出2
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

7：常量指针

关于const与指针的问题，const关键字可以用于修饰指针，有以下几种情况：

1. const修饰指针：const可以放在指针类型前面，表示指针所指向的对象是常量，不能通过该指针修改所指对象的值。例如：

   int value = 5;
   int age {20};
   const int* ptr = &value; // 指针ptr指向的对象是常量
   
    *ptr = 100 //错误，不能通过解引用来修改常量的值
    ptr = &age; //正确，可以通过指针修改指向的地址
   
   
   在上述示例中，`ptr`是一个指向`const int`类型的指针，通过该指针不能修改`value`的值。
   
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10

2. const修饰指针所指向的对象：const可以放在指针变量名前面，表示指针本身是常量，不能通过该指针修改所指对象的值。例如：

   int value = 5;
   int age  {20};
   int* const ptr = &value; // 指针ptr本身是常量
   
   
   *ptr = 100;//正确，通过指针解引用修改值
   ptr = &age;//错误，不能修改指针值
   
   
   
   在上述示例中，`ptr`是一个指向`int`类型的常量指针，即指针本身不可变，一旦指向了某个对象，就不能指向其他对象。
   ```
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12

3. const同时修饰指针和指针所指向的对象：const可以同时修饰指针和指针所指向的对象，表示指针和指针所指向的对象都是常量。例如：

   int value = 5;
   int age  {20};
   const int* const ptr = &value;  // 指针ptr本身和所指对象都是常量
   
   
   *ptr = 100; //错误，不能通过指针解引用修改值
   ptr = &age; //错误，不能修改指针值
     
   
   在上述示例中，`ptr`是一个指向`const int`类型的常量指针，指针本身和所指对象都不可变。
   
   
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12

需要注意的是，const修饰的指针可以指向非const对象，但不能通过该指针修改所指对象的值。而非const指针则可以修改所指对象的值。

希望这个回答能够解决你的问题！如果你还有其他疑问，请随时提问。

8：指针和函数

指针在函数中也经常使用，可以通过指针传递参数或返回指针作为函数的结果。

void modifyValue(int* ptr) {
    (*ptr)++; // 通过指针修改传递进来的值
}

int main() {
    int x = 10;
    int* ptr = &x;
    modifyValue(ptr); // 传递指针给函数
    std::cout << x << std::endl; // 输出11
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11

C++中的指针是一种特殊的数据类型，它存储了一个变量的内存地址。通过指针，程序可以对变量的值和地址进行操作，使得程序具有更高的灵活性和效率。

在C++中，定义一个指针需要使用 * 符号。例如：

int* ptr;
1

上述代码定义了一个整型指针 ptr。

指针可以通过取地址符 & 来获取变量的地址，例如：

int num = 10;
int* ptr = #
1
2

上述代码定义了一个整型变量 num，并且通过指针变量 ptr 获取了 num 的地址。此时，ptr 存储的值就是 num 的地址。

指针可以通过解引用符 * 来获取指针所指向的变量的值，例如：

int num = 10;
int* ptr = #
cout << *ptr; // 输出：10
1
2
3

上述代码通过解引用符 * 获取了 ptr 所指向的 num 变量的值，即输出了 10。

指针还可以用于动态内存分配，例如：

int* arr = new int[10]; // 动态分配长度为 10 的整型数组
1

上述代码使用了 new 操作符动态分配了一个长度为 10 的整型数组，并将数组的首地址赋给了指针变量 arr。此时，arr 就可以像普通数组一样使用。

需要注意的是，指针也可以为空，表示指向的地址为 NULL。在使用指针时需要注意空指针的情况。

指针：int* p_updates：创建一个int*类型的p_updates指针，带 int*符号的就是创建int类型的指针

&updates：前面带个&符号在写上变量名：打印出来的是内存地址
p_updates = &updates：将内存地址赋值到指针变量中
*p_updates  ：打印出来的是&updates地址里面的值。
1
2
3

9：vector类型与函数

如果你有一个vector类型的对象，并且你想在函数中使用它，你可以将该对象作为函数的参数进行传递。以下是一个示例：

#include 
#include 
#include 
using namespace std;

void processStrings(const vector<string>& strings) {
    // 在这里对字符串进行传入
    for (const string& str : strings) {
        cout << str << endl;
    }//打印"Hello"和"World"
}

int main() {
    std::vector<std::string> strings = {"Hello", "World"};

    processStrings(strings);  // 调用函数并传递vector对象

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

在上述示例中，我们定义了一个名为processStrings的函数，它接受一个const std::vector&类型的参数 strings。在函数内部，我们可以像处理普通的vector一样处理这个vector对象。在这个例子中，我们简单地遍历并打印出每个字符串。

通过将vector对象作为参数传递给函数，我们可以在函数内部访问并处理该对象的内容，而无需进行复制。同时，为了避免对strings进行修改，我们将参数声明为const，以确保在函数内部不会修改传递进来的vector对象。

10：函数返回指针

#include 
using namespace std;
  

int *max(int* a, int* b) {
    return (*a>*b) ? a:b;
}

int main() {
    int x {100}, y {200};
    cout << *max(&x,&y) << endl; // 200
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13