文章目录
- 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<iostream>
#include<vector>
#include<algorithm>
using namespace std;
class GreaterFive {
public:
// 一元谓词
// 返回值为bool，参数为一个形式参数
bool operator()(int val) {
if (val > 5) {
return true;
}
else {
return false;
}
}
};
void test01() {
vector<int> v;
for (int i = 0; i < 7; i++) {
v.push_back(i);
}
// 查找容器中大于5的数
vector<int>::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<iostream>
#include<vector>
#include<algorithm>
using namespace std;
class MyCompare {
public:
// 二元谓词
// 返回类型为bool，形式参数为两个
bool operator()(int val1, int val2) {
return val1 > val2;
}
};
void test01() {
vector<int> 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<int>::iterator it = v.begin(); it != v.end(); it++) {
cout << *it << " ";
}
cout << endl;
// 实现自定义降序排序，仿函数来改变排序策略
sort(v.begin(), v.end(), MyCompare());
for (vector<int>::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<iostream>
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<iostream>
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<iostream>
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<iostream>
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;
}
