C++学习——C++基础 - HelloWorld开发者社区

1.缺省

//全缺省 void Func1(int a = 10, int b = 20, int c = 30) { cout << "a=" << a << endl; cout << "b=" << b << endl; cout << "c=" << c << endl; } //半缺省 void Func2(int a, int b, int c) { cout << "a=" << a << endl; cout << "b=" << b << endl; cout << "c=" << c << endl; }

int main() { Func1(); Func1(1); Func1(1,2); Func1(1, 2,3); Func2(1);//Fun2不能接受一个参数 Func2(1, 2);//Fun2不能接受两个参数 Func2(1, 2, 3); return 0; } AI写代码 cpp 运行

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 2.函数重载

//函数重载只有返回值不同，不能构成重载 int Add(int left, int right) { return left + right; }

int Add(double left, double right) { return left + right; }

int Add(long left, long right) { return left + right; } AI写代码 cpp 运行

1 2 3 4 5 6 7 8 9 10 11 12 3.引用

int main() { int a = 1; int& ra = a;//引用——相当于别名 //引用必须在定义的时候初始化 ra = 10; cout << a << endl; return 0; } AI写代码 cpp 运行 1 2 3 4 5 6 7 8 4.引用中const权限问题

int main() { const int a = 0; //int& b = a; //b的类型是int，编译不通过，原因：a是只读，b的类型是int，也就是可读可写的。 const int& b = a;

int c = 1;
int& d = c;
const int& e = c; //c只是可读可写，e变成别名只读
//总结：引用取别名时，变量访问的权限可以缩小，不能放大。

int i = 0;
double db = i;//隐式类型转换
const double& rdb = i;
const float& rf = i;
//变量之间赋值没有权限放大和缩小的关系，只有引用才有
return 0;

} AI写代码 cpp 运行

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 什么是「转换后生成临时变量」（重点！核心中的核心）这是关键，也是所有新手的理解盲区，划重点： ✍️ 结论：C++ 中，所有隐式类型转换的结果，都会生成一个「看不见、摸不着、有独立内存地址」的临时变量这个临时变量有 3 个关键特性： ① 它是编译器「偷偷创建」的，代码里你看不到这个变量的名字，是匿名的； ② 它存储的是「转换后的正确类型值」（比如double d=3.14转int后，临时变量里存的就是3）； ③ 它的生命周期极短，只在当前这一行代码生效，执行完这行就会被编译器销毁。什么是「普通引用无法绑定临时变量」普通引用就是 int&、double& 这种不加const的引用，C++ 的语法规则里有一条「铁律」： ✍️ 语法规则：C++ 不允许普通引用（非 const 引用）绑定到「临时变量」上为什么加了 const 就可以？这是这个知识点的「配套必考点」，之前的代码里，const int& rd = d; 是完全合法的，不会报错，核心原因有 2 个，和上面的禁止规则完美对应： ✍️ 核心结论：C++ 语法明确允许 → const 常量引用可以绑定临时变量原因 1：const 引用是「只读引用」，杜绝了「无效修改」的问题 const int& 表示：这个引用是只读的，你只能通过这个引用「读取值」，永远不能通过这个引用修改值（写rd=100;会直接编译报错）。既然不能修改，就不会出现「修改临时变量无意义」的问题，编译器就允许这种绑定。原因 2：const 引用会「延长临时变量的生命周期」，杜绝了「野引用」的风险这是 const 引用的一个「专属语法福利」： ✍️ 规则：当const引用绑定到临时变量时，编译器会主动延长这个临时变量的生命周期，让临时变量的生命周期和这个 const 引用的生命周期「一样长」。直到这个 const 引用被销毁，临时变量才会被销毁，彻底避免了「野引用」的风险，内存操作完全安全。 5.引用做参数

void swap_cpp(int& r1,int&r2) { int tmp = r1; r1 = r2; r2 = tmp; }

int main() { int a = 0; int b = 1; swap_cpp(a, b); cout << a << b << endl; return 0; } AI写代码 cpp 运行

1 2 3 4 5 6 7 8 9 10 11 12 13 注意区分引用和取地址

int& Add2(int a, int b) { static int c = a + b; return c; }

int main() { int& ret = Add2(1, 2); //Add2(3, 4); //printf("hello world!\n"); cout << "Add2(1,2) is :" << ret << endl; return 0; } //调用Add2(3,4)时返回7，调用printf时返回随机值 //总结：一个函数要使用引用返回，返回变量除了这个函数的作用域还存在，就可以使用引用返回，否则不安全。 //函数使用引用返回的好处-》少创建拷贝一个临时变量 AI写代码 cpp 运行

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 int& Add2(int a, int b) { static int c = 1; c = a + b return c; }

int main() { int& ret = Add2(1, 2); Add2(3,4); cout << "Add2(1,2) is :" << ret << endl; return 0; } //static int c = a + b;只有在定义时才改变它的值，后面再调用Add2不会运行这一行 AI写代码 cpp 运行

1 2 3 4 5 6 7 8 9 10 11 12 13

当把c设置为static时就不会因为栈中Add2被覆盖而改变c的值。 6.传值返回与传引用返回效率问题

struct A { int a[10000]; };

A a;

// 值返回 A TestFunc1() { return a; } // 引用返回 A& TestFunc2() { return a; }

void main() { // 以值作为函数的返回值类型 size_t begin1 = clock(); for (size_t i = 0; i < 100000; ++i) TestFunc1(); size_t end1 = clock();

// 以引用作为函数的返回值类型
size_t begin2 = clock();
for (size_t i = 0; i < 100000; ++i)
    TestFunc2();
size_t end2 = clock();

// 计算两个函数运算完成之后的时间
cout << "TestFunc1 time:" << end1 - begin1 << endl;
cout << "TestFunc2 time:" << end2 - begin2 << endl;

} AI写代码 cpp 运行

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 引用和指针的不同点:

引用概念上定义一个变量的别名，指针存储一个变量地址。引用在定义时必须初始化，指针没有要求引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体没有NULL引用，但有NULL指针在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占4个字节) 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小有多级指针，但是没有多级引用访问实体方式不同，指针需要显式解引用，引用编译器自己处理引用比指针使用起来相对更安全 7.内联函数 1 inline 是一种以空间换时间的做法，省去调用函数额开销。所以代码很长或者有代码比较长 / 递归的函数适宜使用作为内联函数。 2 inline 对于编译器而言只是一个建议，编译器会自动优化，如果定义为 inline 的函数体代码比较长 / 递归等等，编译器优化时会忽略掉内联。 3 inline 不建议声明和定义分离，分离会导致链接错误。因为 inline 被展开，就没有函数地址了，链接就会找不到。 inline(内联)在函数调用的时候展开，不用重复建立销毁栈帧。以空间换时间内联不能声明和定义分离行数太多时也不会展开宏函数缺点 1.不能调试2. 可读性差 inline void Swap(int& a, int& b) { int tmp = a; a = b; b = tmp; }

int main() { int a = 0; int b = 1; Swap(a, b); cout << a <<" " << b << endl; return 0; } AI写代码 cpp 运行

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 8.C++使用nullptr

void fun(int n) { cout << "整形" << endl; }

void fun(int* p) { cout << "整形指针" << endl; }

int main() { //C int* p1 = NULL; //C++11中，推荐像下面这样去用 int* p2 = nullptr;

fun(0);
fun(NULL);
fun(nullptr);
return 0;

} AI写代码 cpp 运行

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

Android进阶之旅-(NDK实战篇之C/C++进阶)

Android进阶之旅-(NDK实战篇之基础知识)

热门文章