7、C++零基础学习之指针

        摘要：第七章主要学习指针、指针与数组、函数等得相关知识。并实战冒泡排序案例。

7.1 指针的定义与使用

        作用：通过指针可以间接访问内存。内存编号是从0开始记录的，一般用十六进制数字表示。可以利用指针标量保存地址

        定义指针：数据类型 * 指针变量

        使用指针：指针前加 * 代表解引用，找到指针只想的内存中的数据。

        如下，P是指针，指向a的内存空间；

•         输出P输出的是内存地址，
•         输出*P，是该内存地址所对应的数值，也就是a；

#include<iostream>
using namespace std;

int main() {
    int a = 10;
    // 定义指针P
    int* p;
    // 让指针P记录变量a的地址，使用&操作符可以将变量的地址赋给指针，以便指针可以指向该变量。
    p = &a;    
    // 使用指针
    cout << "a的地址为： " << p << endl;       //输出a的地址为：11111
    cout << "*p = " << *p << endl;            //输出*p = 10
    cout << "a =  " << a << endl;             //输出a = 10

    system("pause");
    return 0;
}

7.2 指针占用的内存空间

#include<iostream>

using namespace std;

// 指针在32位操纵系统下：占用4个字节空间
// 指针在64位操纵系统下：占用8个字节空间

int main() {
    int a = 10;
    int* p = &a;

    cout << "sizeof(int*) = " << sizeof(int*) << endl;
    cout << "sizeof(float*) = " << sizeof(float*) << endl;
    cout << "sizeof(double*) = " << sizeof(double*) << endl;
    cout << "sizeof(char*) = " << sizeof(char*) << endl;

    system("pause");
    return 0;
}

7.3 空指针

        定义：指针标量指向的内存编号为0的空间

        用途：用于初始化指针变量

        注意：空指针指向的内存无法访问

#include<iostream>
using namespace std;


int main() {
    // NULL就是空指针
    int* p = NULL;
    cout << "p = " << p << endl;           //输出0
    system("pause");
    return 0;
}

7.4 野指针

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

#include<iostream>
using namespace std;

int main() {
    int* p = (int*)0 * 1100;
    cout << *p << endl;
    
    system("pause");
    return 0;
}

7.5 const修饰指针

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

#include<iostream>
using namespace std;

int main() {
    // 1、const修饰常量指针——指针指向可以修改，但是指针指向的值不能修改，也就是10不能改
    // *p = 20； 错误，他是将指针指向的值a=10改成了20
    // p = &b; 正确，指针指向从a指向了b的内存
    int a = 10;
    const int* p1 = &a;
    // 2、const后面跟的常量，所以修饰指针常量；指针指向不可以修改，但是指针指向的值能修改
    // *p = 20； 正确，他是将指针指向的a=10改成了20
    // p = &b; 错误，指针指向从a指向了b的内存
    int b = 20;
    int* const p2 = &b;
    // 3、const修饰指针与常量
    // 指针的指向和值都不能修改
    int c = 20;
    const int* const p3 = &c;

    system("pause");
    return 0;
}

7.6 指针与数组

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

#include<iostream>
using namespace std;

int main() {
    int ary[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
    int* p = &ary[0];
    cout << "数组ary中第一个元素的地址: " << *p << endl;
    // 利用指针遍历数组元素
    // 利用指针拿到数组的首地址， 每个指针在64为中是8个字节，每次加8个字节就是下一个元素
    int* p2 = ary;
    for (int i = 0; i < 10; i++) {
    cout << "数组ary中第 " << i << "个元素地址 " << p2;
    cout << "   数组ary中第 " << i << "个元素 = " << *p2 << endl;
    p2++;}

    system("pause");
    return 0;
}

7.7 指针与函数

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

#include<iostream>
using namespace std;

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

int main() {
    // 地址值传递
    int a = 10;
    int b = 20;
    
    swap(&a, &b);
    cout << "交换后a = " << a << endl;
    cout << "交换后b = " << b << endl;

    system("pause");
    return 0;
}

7.8 冒泡排序案例

#include<iostream>
using namespace std;

// 封装一个函数，利用冒泡排序，实现对整型数组的升序排列
// 函数，参数1：数组首地址， 参数2：数组长度
void swap(int* ary, int len) {
    cout << "输出ary[0] = " << ary[0] << endl;
    cout << "输出ary[1] = " << ary[1] << endl;
    cout << "输出ary[2] = " << ary[2] << endl;
    cout << "输出ary[3] = " << ary[3] << endl;
    for (int i = 0; i < len - 1; i++) {
        for (int j = 0; j < len - i - 1; j++) {
            if (ary[j] > ary[j + 1]) {
                int temp = ary[j + 1];
                ary[j + 1] = ary[j];
                ary[j] = temp;
            }
        }
        for (int k = 0; k < len; k++) {
            cout << ary[k] << "    ";
        }
        cout << endl;
    }
}

int main() {
    // 地址值传递
    int ary[10] = { 42, 52, 312, 344, 565, 46, 17, 28, 319, 110 };
    int ary_len = sizeof(ary) / sizeof(ary[0]);
    cout << "输出sizeof(ary) =  zzz" << sizeof(ary) << endl;
    swap(ary, ary_len);

    system("pause");
    return 0;
}

        上一篇：6、C++零基础学习之函数 

        下一篇：8、C++零基础学习之结构体