C++中的谓词、空指针与野指针、内存四区、引用的详细介绍——C++学习记录05

文章目录

      • 1. 谓词
      • 2. 空指针与野指针
      • 3. 指针常量、常量指针与常量指针常量
      • 4.内存四区
        • 4.1 代码区:存放函数体的二进制代码
        • 4.2 全局区:
        • 4.3 栈区:
        • 4.4 堆区:
      • 5. 引用
        • 5.1基本定义
        • 5.2 引用做形参
        • 5.3 引用的本质
        • 5.4 常量引用

1. 谓词

定义:返回bool类型的仿函数称为谓词
一元谓词:如果operator()接受一个参数,则称为一元谓词
二元谓词:如果operator()接受两个参数,则称为二元谓词
一元谓词示例代码:

#include
#include
#include
using namespace std;

class GreaterFive {
public:
    // 一元谓词
    // 返回值为bool,参数为一个形式参数
    bool operator()(int val) {
        if (val > 5) {
            return true;
        }
        else {
            return false;
        }
    }
};

void test01() {
    vector v;
    for (int i = 0; i < 7; i++) {
        v.push_back(i);
    }
    // 查找容器中大于5的数
    vector::iterator it = find_if(v.begin(), v.end(), GreaterFive());
    if (it == v.end()) {
        cout << "未找到!" << endl;
    }
    else {
        cout << *it << endl;
    }

}


int main()
{
    test01();
    system("pause");        
    return 0;
}

二元谓词示例代码:

#include
#include
#include
using namespace std;



class MyCompare {
public:
    // 二元谓词
    // 返回类型为bool,形式参数为两个
    bool operator()(int val1, int val2) {        
        return val1 > val2;
    }
};

void test01() {

    vector v;
    v.push_back(10);
    v.push_back(20);
    v.push_back(50);
    v.push_back(30);
    v.push_back(40);
    
    // 默认升序排序
    sort(v.begin(), v.end());
    for (vector::iterator it = v.begin(); it != v.end(); it++) {
        cout << *it << " ";
    }
    cout << endl;

    // 实现自定义降序排序,仿函数来改变排序策略
    sort(v.begin(), v.end(), MyCompare());
    for (vector::const_iterator it = v.begin(); it != v.end(); it++) {
        cout << *it << " ";
    }
    cout << endl;
}

int main()
{
    test01();
    system("pause");        
    return 0;
}

2. 空指针与野指针

空指针:空指针不能访问,[0——255]的内存编号为系统占用的内存,不能进行访问
野指针:指针变量指向一个非法的内存地址
例如直接让一个指针指向一个未知的地址,并尝试操作指针的内容

3. 指针常量、常量指针与常量指针常量

指针常量:
int * const p; // 指针的指向不能改变,但是指向的内容可以改变
常量指针:
int const * p; // 指针的指向能改变,但是首次指向的内容不能改变
常量指针常量:
int const * const p; //指针的指向不能改变,指向的内容也不能改变

4.内存四区

4.1 代码区:存放函数体的二进制代码

存放CPU执行的机器指令
代码区是共享的,共享的目的是对频繁执行的程序,只需要在内存中存放一份代码即可
代码区是只读的,只读的原因是防止程序意外地修改它的指令

4.2 全局区:

存放全局变量、静态变量以及常量,由操作系统自动释放

4.3 栈区:

由编译器自动分配释放,存放函数的参数值、局部变量等

注意事项:不要返回局部变量的地址,栈区开辟的数据由编译器自动释放

4.4 堆区:

由程序员分配和释放,若程序员未进行释放,程序结束时由系统进行回收

5. 引用

5.1基本定义

作用:给变量起别名
语法:数据类型 &别名 = 原名
注意事项:引用必须进行初始化,而且一旦初始化后,便不能修改

#include

using namespace std;


void test01() {

    int a = 10;
    int& b = a;            // 重新起名称
    
    cout << "a=" << a << endl;
    cout << "b=" << b << endl;

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

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

int main()
{
    test01();
    system("pause");        
    return 0;
}

例子:当引用b已经指向a时,若新定义一个变量c,再将c复制给b,这不是进行修改引用指向,而是进行赋值操作

#include

using namespace std;

void test02() {
    int a = 10;
    int& b = a;

    int c = 20;
    b = c;            // 这里是进行赋值操作,而不是引用修改操作

    cout << "a = " << a << endl;        // a随着b的操作也会被修改为20
    cout << "b = " << b << endl;        // 发生了赋值操作,此时b也是20
    cout << "c = " << c << endl;        // c = 20

}

int main()
{
    //test01();
    test02();
    system("pause");        
    return 0;
}

运行结果:
在这里插入图片描述

5.2 引用做形参

例子:引用做函数参数时,形参可以实现修改实参的值

#include

using namespace std;

// 交换函数
void swap01(int a,int b) {
    int temp = a;
    a = b;
    b = temp;
}

void swap02(int *a, int *b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}
void swap03(int& a, int& b) {
    int temp = a;
    a = b;
    b = temp;
}
int main()
{
    int a1 = 10;
    int b1 = 20;

    swap01(a1, b1);                // 值传递不能修改实参
    cout << "a1 = " << a1 << endl;
    cout << "b1 = " << b1 << endl;
    
    cout << "-------------------" << endl;
    
    int a2 = 10;
    int b2 = 20;
    swap02(&a2, &b2);
    cout << "a2 = " << a2 << endl;
    cout << "b2 = " << b2 << endl;

    cout << "-------------------" << endl;

    int a3 = 10;
    int b3 = 20;
    swap03(a3, b3);
    cout << "a3 = " << a3 << endl;
    cout << "b3 = " << b3 << endl;

    system("pause");        
    return 0;
}

5.3 引用的本质

引用的本质是在C++内部实现一个指针常量(指针常量:指向不能修改,但是指向的内容可以修改)

int& ref = a;
int* const ref = a;    // 将自动转化为指针常量

5.4 常量引用

作用:常量引用主要来修饰形参,防止误操作
在函数形参列表中,可以加const修饰形参,防止形参被修改

#include
using namespace std;

void showValue(const int& val){
    // val = 10;        // 这里将报错,不能对常量引用进行修改
    cout << "a=" << val << endl;
}

int main(){
    
    int a = 10;
    showValue(a);
    system("pause");
    return 0;
}

你可能感兴趣的:(C++基础,c++,算法,c语言)