C++ 指针 学习笔记

指针

目录

指针

• .1 指针概念（记录地址）
• .2 指针变量的定义与使用
• .3指针所占内存
• .4空指针和野指针
• .5const修饰指针
• .6数组和指针
• .7指针和函数
• .8指针配合数组函数 案例

---

.1 指针概念（记录地址）

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

• 内存编号是从0开始记录的，一般用十六进制数字表示

• 可利用指针变量保存地址

.2 指针变量的定义与使用

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

指针使用：“解引用” ——* +指针名（* 解引用 ，找到指针内存中的数据）可读可写

示例：

#include
using namespace std;
​
int main() {
    //定义指针
    int a = 10;
    int * p;
    //让指针记录变量a的地址
    p = &a;
    cout << "a的地址为：" << &a << endl;
    cout << " 指针p为:" << p << endl;
​
    //使用指针
    //可通过解引用的方式来找到指针指向的内存
    //指针前加 * 代表解引用，找到指针指向的内存中的数据
    *p = 1000;
    cout << "a = " << a << endl;
    cout << "*p = " << *p << endl;
​
    system("pause");
    return 0;
    *p = 1000;
​
}

.3指针所占内存

指针在 x86 系统下，无论什么数据类型，都占用四个字节 （32位）

指针在 x64 系统下，无论什么数据类型，都占用八个字节

int main() {
    
    int a = 10;
    int* p = &a;
    cout << "指针p的地址： " << sizeof(int (*p) )<< endl;
​
    system("pause");
    return 0;
​
}

.4空指针和野指针

空指针（指针初始化，不可访问）

int main() {
    //空指针
    //空指针用于给指针变量进行初始化
    int* p = NULL;
    //空指针是不可以进行访问的
    //0~255之间的内存编号是系统占用的，因此不可以访问
    *p = 100;
    system("pause");
    return 0;
}

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

int main() {
    int* p = (int*)0x1100;
    cout << *p << endl;
}

空指针和野指针不是我们申请的内存空间，不能随意访问

.5const修饰指针

1. coust修饰指针---常量指针

2. const修饰常量---指针常量

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

示例：

int main() {
    int a = 10;
    int b = 20;
​
    //const修饰指针 指针指向可以改 指针指向的值不可以改
    const int* p1 = &a;
    p1 = &b;//正确
    //*p1 = 100;//错误
​
​
​
​
​
    //const修饰常量 指针常量
    //指针指向不可以改，指针指向的值可以改
    int* const p2 = &a;
    *p2 = 100;//正确
    //p2 = &b;//错误，指针指向不可以改
​
​
​
​
    //const修饰指针和常量
    const int* const p3 = &a;
    //指针的指向 指针指向的值 都不可以改
    //*p3 = 100;//错误
    //p3 = &b;//错误
​
    system("pause");
    return 0;
}

.6数组和指针

利用指针访问数组

#include
using namespace std;
int main() {
    int arr[ ] = { 1,2,3,4,5 };
    int* p = arr;
    cout << *p << endl;
​
    for (int i = 0; i < 5; i++) {
        cout << *p << endl;
        p++;
    }
    system("pause");
    return 0;
}

.7指针和函数

作用：利用指针做函数参数 修改参数值

（指针通过地址改变实参值，值传递不改变实参）

void swap01(int a, int b)
    {
        int temp = a;
        a = b;
        b = temp;
        cout << "01a = " << a << endl;
        cout << "01b = " << b << endl;
​
    };
void swap02(int *p1,int *p2) {
    int temp = *p1;
    *p1 = *p2;
    *p2 = temp;
};
int main() {
    int a = 10; 
    int b = 20;
    swap01(a, b);//值传递 不改变实参
    cout << "a = " << a << endl;
    cout << "b = " << b << endl;
    
    swap02(&a, &b);//地址传递 改变实参
    cout << "a = " << a << endl;
    cout << "b = " << b << endl;
​
    system("pause");
    return 0;
}

.8指针配合数组函数 案例

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

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

要点：

1. 创建数组，把一个数组传入函数

2. 冒泡排序

3. 输出打印时传入数组长度(可以不用定义数组长度），int len=sizeof(arr)/sizeof(arr[0])

#include
using namespace std;
void bubbllsort(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;
            }
        }
    }
​
}
//打印函数
void printArray(int arr[], int len)
{
    for (int i = 0; i <= len; i++)
    {
        cout << arr[i] << endl;
    }
}
int main()
{
    int arr[10] = { 3,4,2,1,6,5,7,9.10,8 };
    int len = sizeof(arr) / sizeof(arr[0]);
    bubbllsort(arr, len);
    printArray(arr, len);
​
    system("pause");
    return 0;
}