C++学习-指针-8

最新推荐文章于 2022-02-18 01:48:47 发布

手可摘星辰不去高声语

最新推荐文章于 2022-02-18 01:48:47 发布

阅读量218

点赞数

分类专栏： C / C++

本文链接：https://blog.csdn.net/weixin_44917390/article/details/107997658

版权

C / C++ 专栏收录该内容

11 篇文章 0 订阅

订阅专栏

一、指针的基本概念

作用：可以通过指针间接访问内存

内存编号是从0记录的，一般是使用十六进制数字表示
可以利用指针变量保存地址

二、指针变量的定义和使用

语法：数据类型 * 变量名；

#include <iostream>
using namespace std;

int main()
{
    //定义指针
    int a = 10;
    int *p;
    p = &a; //&为取址符号
    cout << "a的地址是" << &a << endl;
    cout << "p指针：" << p << endl;

    //使用指针
    //*p表示解引用
    *p = 1000; //通过指针找到内存，然后修改那个内存
    cout << "a的值是" << a << endl;

    return 0;
} 

输出：
a的地址是0x62fe1c
p指针：0x62fe1c
a的值是1000

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

#include <iostream>
using namespace std;

int main()
{
    int a = 10;
    int *p = &a;
    cout << "a所占用的空间：" << sizeof(a) << endl;
    cout << "*p所占用的空间：" << sizeof(*p) << endl;  //这里已经是解引用了，相当于a
    cout << endl;
    //在64位的操作系统下都是指针都是8个字节
    cout << "指针p所占用的空间：" << sizeof(p) << endl;
    cout << "sizeof(int *):" << sizeof(int *) << endl;
    cout << "sizeof(float *):" << sizeof(float *) << endl;
    cout << "sizeof(char *):" << sizeof(char *) << endl;
    cout << "sizeof(string *):" << sizeof(string *) << endl;

    return 0;
} 

输出：
a所占用的空间：4
*p所占用的空间：4

指针p所占用的空间：8
sizeof(int *):8
sizeof(float *):8
sizeof(char *):8
sizeof(string *):8

四、空指针和野指针

空指针

指针变量指向内存中编号为0的空间
初始化指针变量
空指针指向的内存是不可以访问的（内存0-255是系统占用的）

#include <iostream>
using namespace std;

int main()
{
    //空指针用来给指针变量初始化
    int *p = NULL; //(NULL:扩展到0)
    //空指针是不可以进行访问的
    *p = 100;
    cout << "*p:" << *p << endl; // 没有返回或者返回错误
    cout << "p:" << p << endl;  // 没有返回或者返回错误

    return 0;
}

野指针

指针变量指向非法的空间

#include <iostream>
using namespace std;

int main()
{
    //指针变量p指向内存地址编号为0x1100的空间
    int *p = (int *)0x1100;

    //访问野指针报错或者没有输出
    cout << *p << endl;
    return 0;
}

五、const修饰指针

const修饰指针有三种情况：（看const后面更的是谁）

const修饰指针 --常量指针
const修饰常量 --指针常量
const即修饰指针，又修饰常量

Example：

int a = 10;
int b = 20;
int * p = &a;

Remember：const视为常量，*视为指针，看谁在前在后连起来念就行；const后面跟什么，什么就不能修改，比如后面跟着*，就是常量指针，那么指针的指向不能修改 <*：指针（的指向）；*p：指针所指向的值>

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

const int *p = &a;

指针的指向可以修改，但是指针指向的值不可以修改

*p = 20 ；错误，指针指向的值不可以改
p = &b ；正确，指针的指向可以改

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

int * const p = &a;

指针指向的值可以改，指针指向的常量不可以改

*p = 20 ；正确；指针指向的值可以改
p = &b ；错误，指针的指向不可以改

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

const int * const p = &a;

指针指向的值不能改，指针指向的常量也不能改

六、指针和数组

利用指针访问数组中元素

#include <iostream>
using namespace std;

int main()
{
    int arr[5] = {1,2,3,4,5};
    int *p = arr; //arr就是数组的首地址
    cout << "利用指针访问第一个元素：" << *p << endl;
    p++; //让指针向后偏移4个字节
    cout << "利用指针访问第二个元素：" << *p << endl;

    //利用指针来遍历数组中的值
    p--;
    for (int i = 0; i < 5; i++)
    {
        cout << *p << endl;
        p++;
    }

    return 0;
}

输出：
利用指针访问第一个元素：1
利用指针访问第二个元素：2
1
2
3
4
5

七、指针和函数

利用指针作函数参考，可以修改实参的值

！这个和函数的值传递有很大的不同！

变量的地址并没有交换，只是因为指针可以修改变量地址所对应的值，但是函数就无法修改内存中的值！！！

#include <iostream>
using namespace std;

void swap(int *p1,  int *p2) 
{
    int temp = *p1; //temp表示的就是a所在的地址所对应的值
    *p1 = *p2;  //将a所在的地址所对应的值换成b所在的地址所对应的值
    *p2 = temp; //将b所在的地址所对应的值换成temp（a所在的地址所对应的值）
}

int main()
{
    int a = 1;
    int b = 2;
    cout << "a:" << a << endl;
    cout << "b:" << b << endl;
    cout << "a的地址:" << &a << endl;
    cout << "b的地址:" << &b << endl;
    swap(&a, &b);
    cout << "交换后a:" << a << endl;
    cout << "交换后b:" << b << endl;
    cout << "交换后a的地址:" << &a << endl; 
    cout << "交换后b的地址:" << &b << endl;


    return 0;
} 

输出：
a:1
b:2
a的地址:0x62fe08
b的地址:0x62fe0c
交换后a:2
交换后ab:1
交换后aa的地址:0x62fe08
交换后ab的地址:0x62fe0c

要是想修改实参就用地址传递，不想修改就用值传递

八、指针、数组、函数

案例描述：封装一个函数，利用冒泡排序，实现对整体数组的升序排序

例如数组：int arr[5] = {9,5,6,7,2};

这里有一个不错的教程：C++ 传递数组给函数

#include <iostream>
using namespace std;

void bubbleSort(int * arr,int len)  //因为arr是形参，所以用int *去接收首地址
{
    for (int i = 0; i < len - 1; i++)
    {
        for (int j = 0; j < len - i - 1; j++)
        {
            if (arr[j] > arr[j + 1]) // 里面的arr[j]是指针数组
            {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}
int main()
{
    //先创建数组
    int arr[5] = {9,5,6,7,2};
    //数组长度
    int len = sizeof(arr) / sizeof(arr[0]);
    //函数实现冒泡排序
    bubbleSort(arr,len);  // 这里传递的arr是首地址

    for (int k = 0; k < len; k++)
    {
        cout << arr[k] << " ";
    }

        return 0;
}

无指针版本：

#include <iostream>
using namespace std;

void bubbleSort(int arr[],int len)  //注意这里的变化
{
    for (int i = 0; i < len - 1; i++)
    {
        for (int j = 0; j < len - i - 1; j++)
        {
            if (arr[j] > arr[j + 1]) 
            {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}
int main()
{
    //先创建数组
    int arr[5] = {9,5,6,7,2};
    //数组长度
    int len = sizeof(arr) / sizeof(arr[0]);
    //函数实现冒泡排序
    bubbleSort(arr,len);  // 传递一个指向数组的指针作为参数

    for (int k = 0; k < len; k++)
    {
        cout << arr[k] << " ";
    }

        return 0;
}

九、关于指针数组

C++ 指针数组:https://www.runoob.com/cplusplus/cpp-array-of-pointers.html

我理解为将数组的每一个元素用指针表示地址，然后形成一个集合的数组

#include <iostream>
 
using namespace std;
const int MAX = 3;
 
int main ()
{
   int  var[MAX] = {10, 100, 200};
   int *ptr[MAX];  //(我的理解)定义一个指针数组
 
   for (int i = 0; i < MAX; i++)
   {
      ptr[i] = &var[i]; // 赋值为整数的地址 //（我的理解）这里的ptr其实就是一个数组，存储另一个数组的每个元素的地址
   }
   for (int i = 0; i < MAX; i++)
   {
      cout << "Value of var[" << i << "] = " << *ptr[i] << endl; // （我的理解）加了*后，对数组中的每个元素的地址进行解引用，得到该地址所对应的元素的值
   }
   return 0;
}

输出：
Value of var[0] = 10
Value of var[1] = 100
Value of var[2] = 200

手可摘星辰不去高声语

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
C++学习-指针-8

目录一、指针的基本概念二、指针变量的定义和使用三、指针所占用的内存空间四、空指针和野指针空指针野指针五、const修饰指针1、const修饰指针——常量指针2、const修饰常量——指针常量3、const即修饰指针，又修饰常量六、指针和数组七、指针和函数八、指针、数组、函数九、关于指针数组一、指针的基本概念作用：可以通过指针间接访问内存内存编号是从0记录的，一般是使用十六进制数字表示可以利用指针变量保存地址二、指针变量的定义和使.
复制链接

扫一扫