目录
1 交换两数 优化算法
代码：
a = a + b;
b = a - b;
a = a - b;
宏定义中因为有3个分号，只能用{}
无分号 只能用()
该部分作为宏定义部分
宏函数是：在源代码文件上的文本替换，没有切换并保护现场的过程，可显著提高代码的执行效率
每当程序流程执行普通函数，为切换、保护现场，普通函数会被压入系统栈，执行结束后又被弹出系统栈，处理器堆栈操作会被反复执行
#include<bits/stdc++.h>
#define num 1000
#define swap(a, b) {a = a + b; b = a - b; a = a - b;}
using namespace std;
void init(int &a, int &b)
{
a = rand()%num;
b = rand()%num;
while( a == b)
{
b = rand()%num;
}
}
void print(int a, int b)
{
cout << "a = " << a << ", b = " << b << endl;
}
void exchange(int &a, int &b)
{
init(a, b);
cout << "初始：" << endl;
print(a, b);
swap(a, b);
cout << "交换后：" << endl;
print(a, b);
cout << endl;
}
int main()
{
srand(time(NULL));
int a, b;
exchange(a, b);
while(getchar() =='\n')
exchange(a, b);
}
2 传参：形参 / 实参
以下均用过子函数交换两数，3个办法：
1 引用传递，可交换
2 指针传递，可交换
3 值传递，不可交换
2.1 注意
无论是int型数据 还是 int型指针数据，对上面三个方法均适用！
代码：
#include<bits/stdc++.h>
#define num 100
using namespace std;
void print(int a, int b)
{
cout << "a = " << a << endl;
cout << "b = " << b << endl << endl;
}
void print2(int p, int q)
{
cout << "*p = " << p << endl;
cout << "*q = " << q << endl << endl;
}
void exchange1(int &a, int &b) // 引用型
{
int c;
c = a; a = b; b = c;
}
void exchange2(int *a, int *b) // 指针型
{
int c;
c = *a; *a = *b; *b = c;
}
void exchange3(int a, int b) // 值传递
{
int c;
c = a; a = b; b = c;
}
int main()
{
srand(time(NULL));
cout << "int型数据，非指针：" << endl;
int a = rand()%num, b = rand()%num;
print(a, b);
cout << "引用传递（可交换）：" << endl;
exchange1(a, b); // 引用型
print(a, b);
exchange1(a, b); // 还原a, b
cout << "指针传递（可交换）：" << endl;
exchange2(&a, &b); // 指针型
print(a, b);
exchange2(&a, &b); // 还原a, b
cout << "值传递（不可交换）:" << endl;
exchange3(a, b); // 值传递
print(a, b);
cout << endl;
/
cout << "int型指针数据：" << endl;
int *p = &a , *q = &b;
print2(*p, *q);
cout << "引用传递（可交换）：" << endl;
exchange1(*p, *q); // 引用型
print2(*p, *q);
exchange1(*p, *q); // 还原a, b
cout << "指针传递（可交换）：" << endl;
exchange2(p, q); // 指针型
print2(*p, *q);
exchange2(p, q); // 还原a, b
cout << "值传递（不可交换）:" << endl;
exchange3(*p, *q); // 值传递
print2(*p, *q);
}
3 知识点
3.1 形参 vs 实参
两者均是变量，数据类型一致(必须)，
形参：被调用才会被分配内存，用完后分配的内存就被释放，我称之为‘工具人’
实参：在函数调用时，必须是确定的值，不仅可以是变量，还可以是常量和表达式
关系：实参单方向传值给形参，形参怎么变化都不影响实参，这样看来，形参 就是 实参的工具人
3.2 特殊值的传递
尝试 用代码去验证各数据类型的范围，对于边界值（特别大 或 特别接近 0），想写进文件中
这些数据类型有(17 种)：
char、
short、short int、
int、long、long int、
long long、及对应无符号数据类型；
float、double、long double
17 种数据类型，只关注不小于0的范围，每个数据类型有 2 个边界值，特别大 或 特别接近 0，有的等于0
欲：每当生成 1 个数据类型的边界值（2 个数），就把它们写进文件，自然想：用子函数来写这个过程，那我的问题是 这些特殊值（特别大的数 或 特别接近 0 的数），它们传到子函数的形参时会出现问题吗？
注意
long double 的整数范围是 [ LDBL_MIN, LDBL_MAX ]
LDBL_MIN、LDBL_MAX都是常数，不能直接传给 引用传递、指针传递！
代码
#include<bits/stdc++.h>
using namespace std;
void test1(long double &p) // 引用传递
{
cout << "p = " << p << endl <<endl;
}
void test2(long double *p) // 指针传递
{
cout << "*p = " << *p << endl <<endl;
}
void test3(long double p) // 值传递
{
cout << "p = " << p << endl <<endl;
}
int main()
{
long double min = LDBL_MIN, max = LDBL_MAX; // LDBL_MAX
cout<< "引用传递 测试："<< endl;
//test1(LDBL_MIN);
test1(min);
//test1(LDBL_MAX);
test1(max);
cout<< "指针传递 测试："<< endl;
//test2(&LDBL_MIN);
test2(&min);
//test2(&LDBL_MAX);
test2(&max);
cout<< "值传递 测试："<< endl;
test3(LDBL_MIN);
test3(min);
test3(LDBL_MAX);
test3(max);
system("pause");
return 0;
}
3.3 取地址符 VS 引用 VS 指针
参考于：
https://blog.csdn.net/ziggyPLAYguitar/article/details/82585259
https://blog.csdn.net/metheir/article/details/59081828
http://blog.chinaunix.net/uid-21411227-id-1826858.html
| 引用 | 取地址符 | |
|---|---|---|
| 形式 | int &b=a ; 在"="左侧 | int *p=&a ; 在"="右侧 |
| 区分 | 和类型在一起，是引用 | 和变量在一起，是取地址 |
| 引用 | 指针 | |
|---|---|---|
| 形式 | int &a = b; 或 int & a = b; 不是 (int &) a = b; | int *p = &b; 或 int * p = &b; 不是 (int *) p = &b; |
(int &) a = b; 或 (int *) p = &b;这样理解是对的，且必须这样理解，但实际中这样写无法通过编译！ | ||
| 相同点 | 1 是对象 “ 地址 ” 的操作： 指针指向内存，自己是所指内存的地址 引用是内存的别名 2 可以优化传参效率 3 所指对象一样时，&a == p 成立 4 对象只能是变量！不能是常量 或 const 型的变量 5 引用可认为是：不能改变的指针 | |
| 不同点 | 1 不占内存 2 不能为空 ( 无 NULL 引用 ) 3 必须初始化 4 初始化后 不能改变 | 1 占内存 2 可以为空 ( 有 NULL 指针 ) 3 可以不初始化 4 初始化后 能改变，能算术运算 |
| 不是变量，仅是引用 ( 别名 ) | 是变量 | |
| 只能 1 级 | 可以多级 ( 存在指向指针 的指针 ) | |
| 各自优点 | 1 不存在指向空值的引用，意味着使用 引用的效率比指针高。因为使用 引用前不需要测试合法性 2 修改调用函数中的数据对象，改变的是对象包含的数据变量，而不是对象本身提高运行速度 | 1 遍历数组 或 频繁引用元素时, 指针效率比下标高 即：p->a 的效率比 (*p).a 的效率高 |
| 选取原则 | 尽可能使用 引用，不得已 使用 指针 引用 - 对象的表面，指针 - 对象内部 | |
| 情况对应选择 | 仅使用 引用： 1 对象不能为空 2 重载某操作符，使用 引用 3 对象是类对象，用 const引用，类设计常要求使用 引用，传递类对象的标准方式是 引用传递 | 仅使用 指针： 1 传递大型结构，且 “ 只读 ” 元素 2 数组，若数组不可改变，指针就声明为指向const 3 动态分配空间 4 要改变实参变量 5 需要 不同时刻 指向 不同对象 6 函数返回指针，如fopen、二级指针 ( 即指针的指针 ) |
| 均可 | 传递的值而不做修改： 1 对象较大，用 const引用 或 const指针，以提高效率，节省复制结构的时间、空间 2 修改对象是结构，使用 引用 或 指针 | |
引用初始化
int *p = c;
if(pInt != NULL)
{
int &rInt = *pInt;
}
&a == p 代码测试
#include<bits/stdc++.h>
using namespace std;
int main()
{
int c = 3;
int & a = c;
int * p = &c;
cout << "&a = " << &a <<endl;
cout << "p = " << p <<endl <<endl;
if(&a == p)
cout << "&a == p " << "成立！" << endl << endl;
system("pause");
return 0;
}
多级指针 - 指针的指针
无论多少级指针，赋值都是：
int ******p = &q;
1 最简单测试代码：
#include<bits/stdc++.h>
using namespace std;
void test(int **r)
{
r = (int **)malloc(sizeof(int*));
if(r != '\0')
cout << "二级指针空间分配成功！" << endl << endl;
}
int main()
{
int c = 3;
int *p = &c; // 一级指针
int **q = &p; // 二级指针
int **r;
cout << "c = " << c << endl;
cout << "*p = " << *p << endl;
cout << "p = " << p << endl;
cout << "**q = " << **q << endl;
cout << "*q = " << *q << endl;
cout << "q = " << q << endl;
test(r);
system("pause");
return 0;
}
2 多级指针 + 数组
参考于：https://blog.csdn.net/qq_43763344/article/details/87827491
#include<bits/stdc++.h>
using namespace std;
int main()
{
char *c[]={"012", "123", "234", "345" };
char **cp[] = {c+1};
char ***cpp = cp;
cout << "c + 1 = " << c + 1 << endl;
cout << "*(c + 1) = " << *(c + 1) << endl << endl;
cout << "**cp = " << **cp << endl;
cout << "*cp = " << *cp << endl << endl;
cout << "***cpp = " << ***cpp << endl;
cout << "*(**cpp+1) = " << *(**cpp+1) << endl;
cout << "*(**cpp+2) = " << *(**cpp+2) << endl;
cout << "**cpp = " << **cpp << endl;
cout << "*cpp = " << *cpp << endl;
system("pause");
return 0;
}
3万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
