自学C++(指针)

最新推荐文章于 2024-08-25 23:50:29 发布

慢学不慌

最新推荐文章于 2024-08-25 23:50:29 发布

阅读量299

点赞数

文章标签：大数据 c++ 开发语言算法

本文链接：https://blog.csdn.net/m0_65334471/article/details/125818776

版权

五、const修饰指针(这一小节需要加深理解)

const修饰指针总结：

六、指针和数组

七、指针和函数(同样需要理解)

一、指针的基本概念

作用：可以通过指针间接访问内存
可以简单的理解为：指针就是一个地址
·内存编号是从0开始记录，一般用十六进制数字表示
·可以利用指针变量保存地址

二、指针的定义及使用

指针定义的语法：数据类型* 指针变量名

代码：

#include <iostream>
using namespace std;
int main()
{
    //1、定义指针
    int a = 10;//定义变量a，并赋值为10；
    int* p;    //定义指针p
    p = &a;    //让指针p指向变量a的地址
    cout << "变量a的地址为：" << &a << endl;//打印变量a的地址
    cout << "指针p指向的地址为：" << p << endl;//打印指针p所指向的地址

    //2、使用指针
    //通过 * 操作(解引用操作)指针指向的内存，可以对其进行访问及修改
    cout << "*p = " << *p << endl;//打印指针p所指向地址中的内容
    
    *p = 1000;//将指针p所指向的地址中的内容改为1000，此时变量a的值也会发生改变
    cout << "a = " << a << endl;//打印变量a的值
    cout << "*p = " << *p << endl;
    system("pause");
    return 0;
}

运行结果：

三、指针所占用的内存空间

需要注意的一点是：不管是什么类型的指针，在32位操作系统下占4个字节，在64位下占8个字节。

这里的操作系统不是电脑的操作系统，而是开发系统。如何查看自己是多少位呢？

代码：

#include <iostream>
using namespace std;
int main()
{
    int a = 10;
    int* p = &a;
    cout << "int型指针所占内存为：" << sizeof(int*) << "字节" <<endl;
    cout << "float型指针所占内存为：" << sizeof(float*) << "字节" << endl;
    cout << "double型指针所占内存为：" << sizeof(double*) << "字节" << endl;
    cout << "char型指针所占内存为：" << sizeof(char*) << "字节" << endl;
    system("pause");
    return 0;
}

运行结果：32位

64位

四、空指针和野指针

空指针：指针变量指向内存中的编号为0的空间，用于初始化指针。

需要注意的是：空指针不能进行访问。

#include <iostream>
using namespace std;
int main()
{
    //初始化指针
    //当我们不知道指针应该指向哪里的时候，就可以将指针初始化为空指针
    int* p = NULL;

    //空指针无法进行访问
    //cout << *p << endl;//虽然这两句代码没有语法错误，但由于空指针无法访问以及修改
    //*p = 100;          //程序依然无法运行
    system("pause");
    return 0;
}

野指针：指针指向非法的内存空间

这样写，如果单独生成这段代码，并不会报错，但如果点击运行，就会报错。

五、const修饰指针(这一小节需要加深理解)

三种情况：const修饰指针、const修饰常量、const既修饰指针，又修饰常量

1、const修饰指针 —— 常量指针

const int* p = &a; 也可以写为 int const * p = &a;第二种写法我觉得更好理解

特点：指针的指向可以修改，指针指向的值不可以修改。(即p可改，*p不可改)

p = &b; 本来p指向a，但现在要让p指向b。这种是正确的。

*p = 20;本来p指向a，a的值为10，但现在要让a的值变为20。这种是错误的。也就是说a的值不可以通过指针来修改，但如果想修改a的值可以直接修改。

也说明 p 和 *p 是不一样的。

2、const修饰常量 —— 指针常量

int * const p = &a;

特点：指针的指向不可以修改，指针指向的值可以修改。(即p不可改，*p可改)

p = &b; 本来p指向a，但现在要让p指向b。这种是错误的。

*p = 20;本来p指向a，a的值为10，但现在要让a的值变为20。这种是正确的。也就是说a的值可以通过指针来修改。

3、const既修饰指针，又修饰常量

const int* const p = &a;

特点：指针的指向、指针指向的值都不可以修改。(即p、*p都不可改)

p = &b;

*p = 61; 两种写法都是错误的。

const修饰指针总结：

·const + 指针 ------> 常量指针

·const + 变量 ------> 指针常量

·const在 * 左边，则const修饰指针，如 const * p，指针指向的值*p不能修改；

·const在 * 右边，则const修饰常量，如* const p，指针的指向p不能修改。

六、指针和数组

利用指针访问数组中的元素。

#include <iostream>
using namespace std;
int main()
{
    int arr[] = { 21,54,78,16,34,94,16 };
    int* p = arr;
    cout << "数组中的第一个元素为：" << arr[0] << endl;
    cout << "利用指针访问数组的第一个元素为：" << *p << endl;
    cout << "利用指针访问数组的所有元素" << endl;
    for(int i = 0; i < sizeof(arr)/sizeof(arr[0]);i++)
    {
        cout << *p << " ";   
        p++;
    }
    cout << endl;
    system("pause");
    return 0;
}

七、指针和函数(同样需要理解)

利用指针作函数参数，可以修改实参的值。(地址传递)

实参的改变，是利用地址去改变的，而不是直接赋值改变的。

#include <iostream>
using namespace std;
void swap(int* p1, int* p2)
{
    int temp = *p1;//将指针p1指向的地址的内容赋给temp变量
    *p1 = *p2;//将指针p2指向的地址的内容赋给指针p1所指向的地址的内容
    *p2 = temp;//将temp变量的内容赋给指针p2指向的地址的内容
}

int main()
{
    int a = 10;
    int b = 20;

    //地址传递时，实参可以修改
    swap(&a,&b);
    //调用swap函数时，我们将变量a和变量b的地址赋给指针p1和p2

    cout << "a = " << a << endl;
    cout << "b = " << b << endl;
    system("pause");
    return 0;
}