指针

指针的定义和使用

指针的基本概念

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

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

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

指针变量的定义和使用

指针变量定义语法

xxxxxxxxxx







数据类型 * 变量名;










例如
xxxxxxxxxx







#include <iostream>

using namespace std;


int main() {
    //1、定义指针
    int a = 10;
    //指针定义的语法 数据类型 * 指针变量名
    int* p;


    p = &a;
    cout << "a的地址为：" << &a << endl;
    cout << "指针p为：" << p << endl;


    //2、使用指针
    //可以通过解引用的方式来找到指针指向的内存
    //指针前加 * 代表解引用，找到指针指向的内存中的数据
    cout << "指针指向的地址中数据为：" << *p << endl;


    //可以直接通过解引用修改地址中的数据
    *p = 1000;
    cout << "修改指针指向的地址中的数据：" << *p << endl;
    cout << "原始地址中的数据为：" << a << endl;


    system("pause");


    return 0;
}









运行

指针所占内存空间


在 32 位系统下，指针是占用 4 个字节空间大小
在 64 位系统下，指针是占用 8 个字节空间大小

32 位下
xxxxxxxxxx







#include <iostream>

using namespace std;
#include <string>


int main() {
    //指针所占内存空间
    int a = 1000;
    bool b = true;
    char c = 'a';
    double d = 7.1;
    string e = "xxxx";


    //定义指针
    int* IntP = &a;
    bool* BoolP = &b;
    char* CharP = &c;
    double* DoubleP = &d;
    string* StringP = &e;


    //打印输出指针占用的内存
    cout << "int类型指针占用的内存为：" << sizeof(IntP) << endl;
    cout << "bool类型指针占用的内存为：" << sizeof(BoolP) << endl;
    cout << "char类型指针占用的内存为：" << sizeof(CharP) << endl;
    cout << "double类型指针占用的内存为：" << sizeof(DoubleP) << endl;
    cout << "string类型指针占用的内存为：" << sizeof(StringP) << endl;


    system("pause");


    return 0;
}









运行

64 位下
xxxxxxxxxx







#include <iostream>

using namespace std;
#include <string>


int main() {
    //指针所占内存空间
    int a = 1000;
    bool b = true;
    char c = 'a';
    double d = 7.1;
    string e = "xxxx";


    //定义指针
    int* IntP = &a;
    bool* BoolP = &b;
    char* CharP = &c;
    double* DoubleP = &d;
    string* StringP = &e;


    //打印输出指针占用的内存
    cout << "int类型指针占用的内存为：" << sizeof(IntP) << endl;
    cout << "bool类型指针占用的内存为：" << sizeof(BoolP) << endl;
    cout << "char类型指针占用的内存为：" << sizeof(CharP) << endl;
    cout << "double类型指针占用的内存为：" << sizeof(DoubleP) << endl;
    cout << "string类型指针占用的内存为：" << sizeof(StringP) << endl;


    system("pause");


    return 0;
}









运行

更改 32位 或 64位
可以通过选项更改 32位 或 64位

空指针 和 野指针

空指针

空指针：指针变量指向内存中编号为 0 的空间
用途：初始化指针变量
注意：空指针指向的内存是不可以访问的

xxxxxxxxxx







#include <iostream>

using namespace std;


int main() {
    //空指针
    //1、空指针用于给指针变量进行初始化
    int* p = NULL;


    //2、空指针是不可以进行访问的
    // 0 - 255 之间的比内存编号是系统占用的，因此不可以访问
    cout << *p << endl;


    system("pause");


    return 0;
}









运行

野指针

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

xxxxxxxxxx







#include <iostream>

using namespace std;


int main() {
    //野指针
    //在程序中，避免出现野指针
    int* p = (int*)0x1100;


    cout << *p << endl;


    system("pause");


    return 0;
}









运行

const 修饰指针

const 修饰指针由三种情况


const 修饰指针 — 常量指针


const 修饰常量 — 指针常量


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


xxxxxxxxxx







#include <iostream>

using namespace std;


int main() {
    int a = 200;
    int b = 400;


    //1、const 修饰指针
    const int* p1 = &a;
    //const 修饰指针后，指针的值不可以更改，但指针指向的地址可以更改
    //*p1 = 400;
    cout << "常量指针的值为：" << p1 << endl;
    p1 = &b;
    cout << "常量指针修改后的值为：" << p1 << endl;
    cout << endl;
    
    //2、const 修饰常量
    int* const p2 = &a;
    //const 修饰变量后，指针的值可以改变，但指针指向的地址不能改变
    cout << "指针常量的值为：" << *p2 << endl;
    *p2 = 600;
    cout << "指针常量修改后的值为：" << *p2 << endl;
    //p2 = &b;


    //3、const 既修饰指针，又修饰常量
    const int* const p3 = &a;
    //既修饰指针又修饰变量之后，不管是指针指向的地址，还是地址中的值都无法改变
    //*p3 = 600;
    //p3 = &b;


    system("pause");


    return 0;

}










运行

指针和数组


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

xxxxxxxxxx







#include <iostream>

using namespace std;


int main(){
    int Array[] = { 10,20,30,40,50,60,70,80,90,100 };
    int* p = Array; //指向数组时，只需要指向数组的首地址即可


    //利用指针获取数组中的每个元素
    for (int i = 0; i < 10; i++)
    {
        cout << "指针获取到的值为：" << *p << endl;
        //因为整型数组中的每个元素之间相隔 4 字节
        //而整型指针每次自增都会增加 4 字节
        //所以可以使用指针自增遍历数组中的所有元素
        p++;
    }


    system("pause");


    return 0;

}










运行

指针和函数


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

x







#include <iostream>

using namespace std;


void swap02(int *p1,int *p2) {
    int temp = *p1;
    *p1 = *p2;
    *p2 = temp;


}


int main() {
    int a = 100;
    int b = 200;
    int* p1 = &a;
    int* p2 = &b;


    cout << "交换之前，实参 p1 的值为：" << *p1 << endl;
    cout << "交换之前，实参 p2 的值为：" << *p2 << endl;
    cout << endl;


    swap02(p1, p2);


    cout << "交换之后，实参 p1 的值为：" << *p1 << endl;
    cout << "交换之后，实参 p2 的值为：" << *p2 << endl;


    system("pause");


    return 0;

}










运行

总结：如果不想修改实参，就用值传递；如果像修改实参，就用地址传递
案例 – 指针、数组、函数
封装一个函数，利用冒泡排序，实现对整型数组的升序排序
x







#include <iostream>

using namespace std;


void Sort(int *p,int Length) {
    int* p2 = NULL;
    int temp = 0;


    for (int i = 0; i < Length; i++)
    {
        p2 = p;
        for (int j = 0; j < Length - 1 -i; j++)
        {
            if (*p2 > *(p2 +1))
            {
                temp = *p2;
                *p2 = *(p2 + 1);
                *(p2 + 1) = temp;
            }
            p2++;
        }
    }
}


int main() {
    int Array[] = { 40,36,25,99,71,84,22,16,46,96,17,1,8,88,91 };
    int* p = Array;
    int ArrayLength = (int)sizeof(Array) / (int)sizeof(Array[0]);


    Sort(p,ArrayLength);


    for (int i = 0; i < ArrayLength; i++)
    {
        cout << *p << endl;
        p++;
    }


    system("pause");


    return 0;

}










运行