黑马自学笔记 C++基础入门 （指针）

目录

7指针

7.1指针的基本概念

7.2指针变量的定义和使用

7.3指针所占的内存空间

7.4空指针和野指针

7.5const修饰指针

7.6指针和数组

7.7指针和函数

7.8指针配合数组和函数案例

---

7指针

7.1指针的基本概念

指针的作用：可以通过指针简介访问内存

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

7.2指针变量的定义和使用

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

示例： 

#include<iostream>
using namespace std;
int main ()
{
    //1、定义指针
    int a = 10;
    //指针定义的语法：数据类型 * 指针变量名
    int * p;
    //让指针记录变量a的地址
    p = &a;
    cout << "a的地址是多少" << &a << endl;//0053F754
    cout << "指针p为；" << p << endl;//0053F754
    //2、使用指针
    //可以通过接应用的方式来找到指针指向的内存
    //指针前加*代表解引用，找到解引用指针的内存中的数据
    *p = 1000;
    cout << "a = " << a << endl;//a = 1000
    cout << "*p = " << *p << endl;//*p = 1000

    return 0;
}

7.3指针所占的内存空间

提问：指针也是种数据类型，那么这种数据类型占用多少内存空间？

 在不同的操作系统中占内存空间大小不同：
在32位操作系统中指针占的内存空间为4个字节

在64为操作系统中指针占的内存空间为8个字节

示例： 

#include<iostream>
using namespace std;
int main ()
{

    int a = 10；
    //int * p;
    //p = &a;
    int * p = &a;

    //在32位操作系统下，指针是占4个字节空间大小，不管什么数据类型
    //在64位操作系统下，指针是占8个字节空间大小，不管什么数据类型
    cout << "sizeof(int*) =" << sizeof(int *) << endl;//4
    cout << "sizeof(int*) =" << sizeof(float *) << endl;//4
    cout << "sizeof(int*) =" << sizeof(double *) << endl;//4
    cout << "sizeof(int*) =" << sizeof(char *) << endl;//4


    return 0;
}

7.4空指针和野指针

空指针：指针变量指向内存中编号位0的空间

用途：初始化指针变量

注意：空指针指向的内存是不可以访问的

示例： 

#include<iostream>
using namespace std;
int main ()
{

    //空指针
    //1、空指针用于给指针变量初始化
    int * p = NULL;//NULL表示0

    //2、空指针是不可以进行访问的
    //0~255之间的内存编号是系统占用的，因此不可以访问
    *p = 100;//错误，写入访问程序冲突


    retuen 0;
}

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

示例：

#include<iostream>
using namespace std;
int main ()
{

    //野指针
    //在程序中，尽量避免出现野指针
    int*p = (int*)0x1100;
    cout << *p << endl;//错误，读取访问权限冲突 

return 0;
}

7.5const修饰指针

const修饰指针有三种情况：

1. const修饰指针 ---常量指针
2. const修饰常量 ---指针常量
3. const即修饰指针，又修饰常量

 第一种：const修饰指针 ---常量指针

cont int * p = &a;

 常量指针

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

 例：

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

第二种： const修饰常量 ---指针常量

int * const = &a

指针常量

特点：指针的指向不可以改 ，但是指针指向的值可以改

例： 

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

第三种：const即修饰指针，又修饰常量

const int * const p = &a;

 特点：指针的指向和指针指向的值都不可以改

例：

*p = 20；//错误
p = &b;//错误

三种情况具体讲解和记忆方法

示例：

#include<iostream>
using namespace std;
int main ()
{

    //1、const修饰指针 ---常量指针
    int a =10;
    int b = 10;
    const int * p = &a;
    //指针指向的值不可以改，指针的指向可以改
    //*p = 20;错误
    p = &b;//正确

    //2、const修饰常量 ---指针常量
    //指针指向的值可以改，指针的指向不可以改
    int * const p2 = &a;
    *p2 = 100；//正确
    //p2 = &b;//错去，指针的指向不可以改
    
    //3、const即修饰指针，又修饰常量
    //指针指向的值和指针的指向都不可以改
    const int * const p3 = &a;
    *p3 = 100;错误
    p3 = &b;错误
    
    return 0;
}

7.6指针和数组

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

示例：

#include<iostream>
using namespace std;
int main ()
{

    //指针和数组
    //利用指针来访问数组中的元素
    
    int arr[10] = {1,2,3,4,5,6,7,8,9,10};
    
    cout << "第一个元素为：" << arr[0] << endl;
    
    int * p = arr;//arr就是数组的首地址

    cout << "利用指针访问第一个元素：" << *p << endl;
    
    p++;//向后移四个字节
    
    cout << "利用指针访问第二个元素：" << *p << endl;

    //利用指针访问整个数组
    int * p2 = arr;
    for(int i = 0;i < 10;i++)
    {
    //cout << arr[i] << endl;
    cout << *p2 << endl;
    p2++;
    }
    
    return 0;
}

7.7指针和函数

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

示例：

#include<iostream>
using namespace std;

//实现两个数字进行交换
void swap01(int a, int b)
{
    int temp = a;
    a = b;
    b = temp;

    cout << "swap01 a = " << a << endl;//a = 20;
    cout << "swap01 b = " << b << endl;//b = 10;
}

//实现地址交换
void swap02(int *p, int *p2)
{
    int temp = *p1;
    *p1 = *p2;
    *p2 = temp;
}

int main ()
{

    //指针和函数
    //1、值传递
    
    int a = 10;
    int b = 20;
    swap01(a,b);
    cout << "a = " << a << endl;//a = 10;
    cout << "b = " << b << endl;//b = 20;

    //2、地址传递
    //如果是地址传递，可以修饰实参
    int a =10;
    int b =20;
    swap02(&a,&b);

    cout << "a = " << a << endl;//a = 10;//a = 20;
    cout << "b = " << b << endl;//b = 20;//b = 10;

//验证时要将另一部分注释掉
    return 0;
}

​​​​​​地址传递讲解

7.8指针配合数组和函数案例

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

例如数组：int arr [10] = {4,3,6,9,1,2,10,8,7,5}

示例：

#include<iostream>
using namespace std;

//冒泡排序 参数1 是数组的首地址  参数2 是数组的长度
void bubbleSort(int * arr, int * len)
{
    for(int i = 0;i < len-1;i++)
    {
        for(int j = 0;j < len- i -1;j++)
        {
            //如果j > j+1的值 交换数字
            if(arr[j] > arr[j+1])
            {
                int temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
    }
}

//打印数组
void prinArray(int * arr,int len)
{
    for(int i = 0;i < len;i++)
    {
    cout << arr[i] endl;
    }
}

int main ()
{
    //1、先创建数组
    int arr[10] = {4,3,6,9,1,2,10,8,7,5}
    
    int len = sizeof(arr)/sizeof(arr[0]);
    //2、创建函数，实现冒泡排序
    bubbleSort(arr,len);
    //3、打印排序后的数组
    prinArray(arr,len);
    //实现升序序列
    return 0;
}

要点：

1. 如何将数组传递到函数中，用指针传递
2.  冒泡排序熟练掌握
3. 打印数组时传递数组长度