【C++总结】02：指针

hello world 999

已于 2024-03-09 08:17:36 修改

阅读量1.7k

点赞数

分类专栏： C++ 文章标签： c++

于 2022-02-07 22:25:40 首次发布

本文链接：https://blog.csdn.net/weixin_49167174/article/details/122815664

版权

C++ 专栏收录该内容

11 篇文章 2 订阅

订阅专栏

指针

一、指针

1.指针的定义和使用：

指针的作用：通过指针间接访问内存（使用指针记录地址编号）

#include <iostream>
using namespace std;

int main() {
    //1.定义一个指针
    int a = 10;
    //定义指针的语法：数据类型*指针变量
    int *p;
    //让指针记录变量a的地址
    p = &a;

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

    //2.指针的使用
    /*
    (1)可以通过解引用的方式来找到指针指向的内存
    (3)指针前加上*代表解引用，找到指针指向的内存中的数据
    */
    *p = 1000;

    cout << "a = " << a << endl;
    cout << "*p = " << *p << endl;

    return 0;
}

2.指针所占用内存空间：

#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(p) << endl;
    cout << "sizeof(int *) = " << sizeof(int *) << endl;
    cout << "sizeof(double *) = " << sizeof(double *) << endl;
    cout << "sizeof(char *) = " << sizeof(char *) << endl;

    system("pause");
    return 0;
}

3.空指针和野指针：

空指针：指针变量指向内存中编号为0的空间，用于初始化指针变量

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

#include <iostream>
using namespace std;

int main() {
    //空指针
    //1.空指针用于初始化指针变量
    int * p = NULL;
    //2.空指针是不可以直接进行访问的
    //0-255之间的内存编号是系统占用的，因此不可以访问

    *p = 100;

    cout << *p << endl;

    system("pause");
    return 0;
}

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

#include <iostream>
using namespace std;

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

    system("pause");
    return 0;
}

注意：空指针和野指针都不是我们申请的内存空间，因此都不要访问

4.const修饰指针：

const修饰指针三种情况
const修饰指针	const ptr常量指针
const修饰常量	ptr const指针常量
const既修饰指针，又修饰常量

常量指针const int *p = &a;：指针的指向可以修改，但指针指向的值不可修改

指针常量int * const p = &a;：指针的指向不可修改，但指针指向的值可以修改

既修饰指针，又修饰常量const int * const p = &a;：指针的指向和指针指向的值都不可修改

5.指针和数组：

学习目标：利用指针访问数组中的元素

#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; cout << "利用指针访问数组第一个元素：" << *p << endl;
    p++; cout << "利用指针访问数组第二个元素：" << *p << endl;

    cout << "利用指针遍历整个数组：" << endl;
    int * p2 = arr;
    for (int i = 0; i < 10; i++, p2++) cout << *p2 << " ";
    cout << endl;

    system("pause");
    return 0;
}

6.指针和函数：

学习目标：指针作为函数参数时，可以修改实参的值

函数中参数值传递：

#include <iostream>
using namespace std;

void swap01(int a, int b) {
    int temp = a;
    a = b;
    b = temp;

    cout << "swap01 a = " << a << endl;
    cout << "swap01 b = " << b << endl;
}

int main() {
    //指针和函数
    //1.值传递
    int a = 10;
    int b = 20;
    swap01(a, b);

    cout << "a = " << a << endl;
    cout << "b = " << b << endl;

    system("pause");
    return 0;
}

函数中参数地址传递：

#include <iostream>
using namespace std;

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

    cout << "swap01 a = " << a << endl;
    cout << "swap01 b = " << b << endl;
}

int main() {
    //指针和函数
    //2.地址传递
    int a = 10;
    int b = 20;
    swap02(&a, &b);

    cout << "a = " << a << endl;
    cout << "b = " << b << endl;

    system("pause");
    return 0;
}

结论：如果是地址传递，可以对实参进行修饰

7.指针案例：

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

/*重点：
1.函数如何接收一个数组参数
2.冒泡排序的基本使用 */
#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;
            }
        }
    }
}

void printArray(int *arr, int len) {
    for (int i = 1; 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.打印排序后的数组
    printArray(arr, len);

    return 0;
}

二、内存分区模型

Cpp程序在执行时，将内存大方向划分为4个区域：栈区、堆区、全局/静态存储区、代码区、

栈区：由编译器自动分配释放，存放函数的参数值、局部变量等
堆区：由程序员分配和释放，若程序员不释放，程序结束时由操作系统进行回收
全局区：存放全局变量、静态变量、及常量
代码区：存放函数体的二进制代码，由操作系统进行管理

内存分区的意义：不同区域存放的数据，赋予了不同的生命周期，给我们更大的灵活编程

1.代码区：

代码区主要存放了CPU执行的机器指令。

代码区内容是共享的，目的是对于频繁被执行的程序，只需要在内存中有一份代码即可

代码区内容是只读的，目的是防止程序意外的修改了它的指令

2.全局区：

全局区主要存放了全局变量、静态变量（static）、及常量

全局区的数据在程序结束后由操作系统控制释放（生命周期由操作系统管理）

注意：代码区域全局区的概念是在代码运行前就有的概念，而栈区和堆区是在程序运行后才有的概念

3.栈区：

栈区由编译器自动分配释放，主要存放内容是函数的参数值、局部变量等

注意：不要返回局部变量的地址，栈区开辟的数据由编译器自动释放（生命周期结束）

4.堆区imp：

堆区由程序员分配和释放，若程序员不释放，程序结束时由操作系统进行回收。

在C++中主要使用new关键字在堆区进行内存的开辟。

5.new操作符：

C++中利用new操作符在堆区开辟内存，利用操作符delete释放堆区内存；

语法：new 数据类型，利用new创建的数据，会返回该数据相应类型的指针

#include<iostream>
using namespace std;

int * func() {
    //利用new关键字在堆区开辟内存，返回地址
    //指针本质也是局部变量，放在栈上，指针保存的数据是放在堆区
    int * p = new int(10);
    return p;
}

//1.new的基本语法
void test01() {
    int *p = func();
    cout << *p << endl;
    cout << *p << endl;
    cout << *p << endl;
    //释放变量堆区内存
    delete p;
    cout << *p << endl;
}

//2.在堆区中开辟一个数组
void test02() {
    int * arr = new int[10];//10代表数组有10个元素

    for (int i = 0; i < 10; ++i) {
        arr[i] = i + 100;
    }
    for (int i = 0; i < 10; ++i) {
        cout << arr[i] << endl;
    }
    //释放数组堆区内存
    delete[] arr;
}

int main() {
    //1.new的基本语法
    test01();
    //2.在堆区利用new开辟数组
    test02();
    system("pause");
    return 0;
}

三、C++中的引用

1.引用的基本使用：

作用：给变量起别名

语法：数据类型 &别名 = 原名

#include<iostream>
using namespace std;

int main(){
    int a = 10;
    //创建引用
    int &b = a;

    cout << "a = " << a << endl;
    cout << "b = " << b << endl;
    system("pause");
    return 0;
}

注意：

引用必须进行初始化（不允许出现int &b;）
引用在初始化之后，便不可以再改变（c = b;赋值操作，不是在更改引用）

2.引用做函数参数：

作用：函数传递参数时，可以利用引用技术让形参修饰实参。

优点：可以简化指针修改实参，

#include<iostream>
using namespace std;

//交换函数
//1.值传递
void mySwap01(int a, int b) {
    int temp = a;
    a = b;
    b = temp;
}
//2.地址传递(用指针接收地址)
void mySwap02(int *a, int *b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}
//3.引用传递()
int mySwap03(int &a, int &b) {
    int temp = a;
    a = b;
    b = temp;
}

int main(){
    int a = 10;
    int b = 20;
    //mySwap01(a, b);//值传递，形参不会修饰实参
    //mySwap02(&a, &b);//地址传递，形参会修饰实参
    mySwap03(a, b);//引用传递，形参会修饰实参

    cout << "a = " << a << endl;
    cout << "b = " << b << endl;

    system("pause");
    return 0;
}

总结：通过引用参数产生的效果同按地址传递是一样的效果，引用的语法更清楚简单。

3.引用做函数返回值：

作用：引用是可以作为函数的返回值存在的

用法：函数调用作为左值

注意：

不要返回局部变量引用
函数的调用可以作为左值存在

#include<iostream>
using namespace std;

//引用做函数返回值
//1.不要返回局部变量的引用
int& test01() {
    int a = 10;//局部变量存放在四区中的 栈区
    return a;
}
//2.函数的调用可以作为左值
int& test02() {
    static int a = 10;//静态变量存放在四区中的 全局区，全局区上的数据在程序结束后由系统释放
    return a;
}

int main(){
    //1.不要返回局部变量的引用
    int &ref = test01();//在test01中将a的别名进行返回，在main函数中使用ref接住
    //cout << "ref = " << ref << endl;//第1次结果可能会正确，是因为编译器做了保留
    //cout << "ref = " << ref << endl;//第2次结果错误，因为a的内存已经释放(非法操作)

    int &ref2 = test02();
    cout << "ref2 = " << ref2 << endl;//第1次结果可能会正确，是因为编译器做了保留
    cout << "ref2 = " << ref2 << endl;//第2次结果也是正确，只有在整个程序执行完后才会被释放

    //2.函数的调用可以作为左值
    test02() = 1000;//如果函数的返回值是引用，那么这个函数调用可以作为左值
    cout << "ref2 = " << ref2 << endl;
    cout << "ref2 = " << ref2 << endl;

    system("pause");
    return 0;
}

4.引用的本质：

本质：在C++内部实现的一个指针常量（一旦初始化后就不可发生改变）

#include<iostream>
using namespace std;

//发现是引用，转换为 int* const ref = &a;
void func(int& ref) {
    ref = 100;//ref是引用，转换为*ref = 100
}

int main() {
    int a = 10;

    int& ref = a;//自动转换为int* const ref = &a; 指针常量是指针指向不可改变，也说明为什么引用不可改变
    ref = 20;//内部发现ref是引用，自动帮我们转换为: *ref = 20;

    cout << "a : " << a << endl;
    cout << "b : " << b << endl;
    func(a);

    return 0;
}

注：C++推荐使用引用技术（语法方便），其本质是指针常量（所有的指针操作编译器都帮我们完成了）

5.常量引用：

作用：常量引用主要用来修饰形参，防止误操作

语法：const 数据类型 &别名

注：在形参列表中可以使用const修饰形参，防止形参改变实参

#include<iostream>
using namespace std;

//发现是引用，转换为 int* const ref = &a;
void showValue(const int &val) {
    cout << "val = " << val << endl;
}

int main() {
    //常量引用
    //使用场景：修饰形参，防止误操作

    /*
    int a = 10;
    int& ref = a;//1.引用必须应用一块合法的内存空间(栈区or堆区)，常量10在常量区(int& ref = 10;为非法)
    const int& ref = 10;//2.加上const之后 编译器可自动将代码修改为int temp = 10; const int& ref = temp;
    */
    int a = 100;
    showValue(a);
    cout << "a = " << a << endl;

    return 0;
}

hello world 999

关注

0
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
【C++总结】02：指针

Cpp基础语法（二）OVERVIEWCpp基础语法（二）1.内存的分区模型（1）代码区：（2）全局区：（3）栈区：（4）堆区imp：（5）new操作符：2.C++中的引用（1）引用的基本使用：（2）引用做函数参数：（3）引用做函数返回值：（4）引用的本质：（5）常量引用：3.函数高级（1）函数的默认参数：（2）函数的占位参数：（3）函数重载：（4）函数重载特殊问题（难点）：case1：引用作为函数的重载条件case2：函数重载遇到函数的默认参数4.C++文件操作：（1）文本文件：<1>指定文
复制链接

扫一扫