【C++】C++指针

最新推荐文章于 2024-10-04 17:07:53 发布

珍心

最新推荐文章于 2024-10-04 17:07:53 发布

阅读量132

点赞数

分类专栏： C++ 文章标签： c++ 指针

本文链接：https://blog.csdn.net/yuzhangzhen/article/details/111076607

版权

C++ 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

学而不思则罔，思而不学则殆

【C++】C++指针

什么是指针
指针的声明

什么是指针

指针是一个变量，其值为另一个变量的地址，即，内存位置的直接地址。
比如：

//指针学习
void func006() {
    int  var1 = 1;
    int  var2 = 1;
    cout <<"var1 变量的地址： "<< &var1 << endl;
    cout <<"var2 变量的地址： "<< &var2 << endl;
}

当上面的代码被编译和执行时，它会产生下列结果：

var1 变量的地址： 0087FDAC
var2 变量的地址： 0087FDA0

指针的声明

type *var-name;

    int  var1 = 1;
    int  var2 = 1;
    //指针申明
    int *ip1 = &var1;
    int *ip2 = &var2;

    cout << "ip1 变量的值： " << ip1 << endl;
    cout << "ip2 变量的值： " << ip2 << endl;

当上面的代码被编译和执行时，它会产生下列结果：

ip1 变量的值： 012FFDDC
ip2 变量的值： 012FFDD0

指正的使用

//指针学习
void func006() {
    int  var1 = 1;
    int  var2 = 1;
    cout <<"var1 变量的地址： "<< &var1 << endl;
    cout <<"var2 变量的地址： "<< &var2 << endl;

    //指针申明
    int *ip1 = &var1;
    int *ip2 = &var2;

    //输出指针变量中的值
    cout << "ip1 变量的值： " << ip1 << endl;
    cout << "ip2 变量的值： " << ip2 << endl; 
    //输出指向指针变量的地址
    cout << "ip1 变量的地址： "<< &ip1 << "\t" << endl;
    cout << "ip2 变量的地址： "<< &ip2 << "\t" << endl;   
    //输出指针中地址的值
    cout << "ip1 变量的值： " <<*ip1 << endl;
    cout << "ip2 变量的值： " <<*ip2 << endl;
}

当上面的代码被编译和执行时，它会产生下列结果：

ip1 变量的值： 004FFBE8
ip2 变量的值： 004FFBDC
ip1 变量的地址： 004FFBD0
ip2 变量的地址： 004FFBC4
ip1 变量的值： 1
ip2 变量的值： 1

NULL指针

在变量声明的时候，如果没有确切的地址可以赋值，为指针变量赋一个 NULL 值是一个良好的编程习惯。赋为 NULL 值的指针被称为空指针。

NULL 指针是一个定义在标准库中的值为零的常量。请看下面的程序：

//vcruntime.h
#ifndef NULL
    #ifdef __cplusplus
        #define NULL 0
    #else
        #define NULL ((void *)0)
    #endif
#endif

//NULL指针
void func007() {
    int  *ip = NULL;
    cout<<"ip的值是：" <<ip <<endl;
}

当上面的代码被编译和执行时，它会产生下列结果：

ip的值是：00000000

在大多数的操作系统上，程序不允许访问地址为 0 的内存，因为该内存是操作系统保留的。然而，内存地址 0 有特别重要的意义，它表明该指针不指向一个可访问的内存位置。但按照惯例，如果指针包含空值（零值），则假定它不指向任何东西。
如需检查一个空指针，您可以使用 if 语句，如下所示：

if(ptr)     /* 如果 ptr 非空，则完成 */
if(!ptr)    /* 如果 ptr 为空，则完成 */

因此，如果所有未使用的指针都被赋予空值，同时避免使用空指针，就可以防止误用一个未初始化的指针。很多时候，未初始化的变量存有一些垃圾值，导致程序难以调试。

指针的算术运算

指针是一个用数值表示的地址。因此，您可以对指针执行算术运算。可以对指针进行四种算术运算：++、–、+、-。
假设 ptr 是一个指向地址 1000 的整型指针，是一个 32 位的整数，让我们对该指针执行下列的算术运算：

ptr++；

在执行完上述的运算之后，ptr 将指向位置 1004，因为 ptr 每增加一次，它都将指向下一个整数位置，即当前位置往后移 4 个字节。这个运算会在不影响内存位置中实际值的情况下，移动指针到下一个内存位置。如果 ptr 指向一个地址为 1000 的字符，上面的运算会导致指针指向位置 1001，因为下一个字符位置是在 1001。

指针递增

测试代码：定义一个数组。

//指针的运算
void func008() {
    const int MAX = 5;
    int  var[MAX] = { 10, 100, 200,4000,5000 };
    int *ptr;

    // 指针中的数组地址
    ptr = var;
    for (int i = 0; i < MAX+5; i++){
        cout << "Address of var[" << i << "] = ";
        cout << ptr << "\t";

        cout << "Value of var[" << i << "] = ";
        cout << *ptr << endl;

        // 移动到下一个位置
        ptr++;
    }
}

数据长度为5，测试的时候多加了5个长度，观察一下未初始化的地址中的数据。
当上面的代码被编译和执行时，它会产生下列结果：

Address of var[0] = 003CFC1C    Value of var[0] = 10
Address of var[1] = 003CFC20    Value of var[1] = 100
Address of var[2] = 003CFC24    Value of var[2] = 200
Address of var[3] = 003CFC28    Value of var[3] = 4000
Address of var[4] = 003CFC2C    Value of var[4] = 5000
Address of var[5] = 003CFC30    Value of var[5] = -858993460
Address of var[6] = 003CFC34    Value of var[6] = -858993460
Address of var[7] = 003CFC38    Value of var[7] = 5
Address of var[8] = 003CFC3C    Value of var[8] = -858993460
Address of var[9] = 003CFC40    Value of var[9] = 370585947

首先可以看到地址那一栏，是累加的，每次比上一次多4个字节。Value那一栏，前五个是数组中定义的数据。后五个则是一些随机的数据。我们可以访问，只是没有意义。

指针递减

//指针的运算 递减
void func009() {
    const int MAX = 5;
    int  var[MAX] = { 10, 100, 200,4000,5000 };
    int* ptr;
    
    //指针中最后一个元素的地址
    ptr = &var[MAX - 1];
    for (int i = MAX - 1; i >= 0; i--){
        cout << "Address of var[" << i << "] = ";
        cout << ptr << "\t";

        cout << "Value of var[" << i << "] = ";

        cout << *ptr << endl;

        // 移动到上一个位置
        ptr--;
    }
}

当上面的代码被编译和执行时，它会产生下列结果：

Address of var[4] = 004FF80C    Value of var[4] = 5000
Address of var[3] = 004FF808    Value of var[3] = 4000
Address of var[2] = 004FF804    Value of var[2] = 200
Address of var[1] = 004FF800    Value of var[1] = 100
Address of var[0] = 004FF7FC    Value of var[0] = 10

指针的比较

指针可以用关系运算符进行比较，如 ==、< 和 >。如果 p1 和 p2 指向两个相关的变量，比如同一个数组中的不同元素，则可对 p1 和 p2 进行大小比较。

下面的程序修改了上面的实例，只要变量指针所指向的地址小于或等于数组的最后一个元素的地址 &var[MAX - 1]，则把变量指针进行递增：

//指针的运算 比较
void func010() {
    const int MAX = 5;
    int  var[MAX] = { 10, 100, 200,4000,5000 };
    int* ptr;

    // 指针中第一个元素的地址
    ptr = var;
    int i = 0;
    //小于等于最后一个指针的位置，循环获取内存中的数据
    while (ptr <= &var[MAX - 1])
    {
        cout << "Address of var[" << i << "] = ";
        cout << ptr << "\t";

        cout << "Value of var[" << i << "] = ";
        cout << *ptr << endl;

        // 指向上一个位置
        ptr++;
        i++;
    }
}

当上面的代码被编译和执行时，它会产生下列结果：

Address of var[0] = 00B5FD0C    Value of var[0] = 10
Address of var[1] = 00B5FD10    Value of var[1] = 100
Address of var[2] = 00B5FD14    Value of var[2] = 200
Address of var[3] = 00B5FD18    Value of var[3] = 4000
Address of var[4] = 00B5FD1C    Value of var[4] = 5000

指向指针的指针（多级间接寻址）

指向指针的指针是一种多级间接寻址的形式，或者说是一个指针链。通常，一个指针包含一个变量的地址。当我们定义一个指向指针的指针时，第一个指针包含了第二个指针的地址，第二个指针指向包含实际值的位置。
也可以叫做指向地址的地址
一个指向指针的指针变量必须如下声明，即在变量名前放置两个星号。例如，下面声明了一个指向 int 类型指针的指针：

int **ptr;

demo:

//指针的运算 指针的指针
void func011() {

    int var = 5000;
    int *ptr;
    int **pptr;

    // 获取 var 的地址
    ptr = &var;

    // 使用运算符 & 获取 ptr 的地址
    pptr = &ptr;

    // 使用 pptr 获取值
    cout << "var 值为 :" << var << endl;
    cout << "ptr 地址为:" << ptr << "\t*ptr 值为:" << *ptr << endl;
    cout << "pptr 地址为:" <<pptr<< "\t**pptr 值为:" << **pptr << endl;
}

当上面的代码被编译和执行时，它会产生下列结果：

var 值为 :5000
ptr 地址为:0019FD08     *ptr 值为:5000
pptr 地址为:0019FCFC    **pptr 值为:5000

内存模型如下：
在这里插入图片描述
首先在内存有一块区域是var的值存放的地方，这块内存的地址是0x0019FD08。
ptr是指针，该指针指向0x0019FD08这块地址，也就是var
而pptr是指向指针的指针，指向0x0019FCFC这块地址，也是存放ptr这个指正的地址。

传递指针给函数

C++ 允许您传递指针给函数，只需要简单地声明函数参数为指针类型即可。

void getSeconds(unsigned long* par);
//指针 指针作为参数
void func012() {
    unsigned long sec = 5000;
    // 输出实际值1
    cout << "Number of seconds 1 :" << sec << endl;
    getSeconds(&sec);
    // 输出实际值2
    cout << "Number of seconds 2 :" << sec << endl;
}

void getSeconds(unsigned long* par){
    // 获取当前的秒数
    *par = time(NULL);
    return;
}

当上面的代码被编译和执行时，它会产生下列结果：

Number of seconds 1 :5000
Number of seconds 2 :1607780573

传递数组给函数

// 函数声明
double getAverage(int* arr, int size);

//指针 指针作为参数
void func013() {
    // 带有 5 个元素的整型数组
    int balance[5] = { 1, 2, 3,4, 50 };
    double avg;
    // 传递一个指向数组的指针作为参数
    avg = getAverage(balance, 5);
    // 输出返回值
    cout << "Average value is: " << avg << endl;
}

double getAverage(int* arr, int size){
    int    i, sum = 0;
    double avg;

    for (i = 0; i < size; ++i){
        sum += arr[i];
    }

    avg = double(sum) / size;
    return avg;
}

当上面的代码被编译和执行时，它会产生下列结果：

Average value is: 12

从函数返回指针

void func014() {
    // 一个指向整数的指针
    int* p;

    p = getRandom();
    for (int i = 0; i < 10; i++)
    {
        cout << "*(p + " << i << ") : ";
        cout << "\t"<< p+i<<"\t: ";
        cout << *(p + i) << endl;
    }
}

// 要生成和返回随机数的函数
int* getRandom()
{
    static int  r[10];
    // 设置种子
    srand((unsigned)time(NULL));
    for (int i = 0; i < 10; ++i)
    {
        r[i] = rand();
        cout << r[i] << endl;
    }
    return r;
}

当上面的代码被编译和执行时，它会产生下列结果：

18980
14920
11411
23999
388
16908
18402
16198
24792
15766
*(p + 0) :      0052260C        : 18980
*(p + 1) :      00522610        : 14920
*(p + 2) :      00522614        : 11411
*(p + 3) :      00522618        : 23999
*(p + 4) :      0052261C        : 388
*(p + 5) :      00522620        : 16908
*(p + 6) :      00522624        : 18402
*(p + 7) :      00522628        : 16198
*(p + 8) :      0052262C        : 24792
*(p + 9) :      00522630        : 15766