//缺省参数 void test(int a = 10) { cout << a << endl; }int main() { test(); //10没有传参时，使用参数的默认值 test(20); //20传参时，使用指定的实参 return 0; }

int add(int a = 10,int b = 20) { return a + b; }int main() { int ret = (); //30 int ret2 = add(100,200); //300 int ret3 = add(100); //120 return 0; }

//半缺省 void Fun(int a,int b = 20,int c = 30) { cout << a << endl; cout << b << endl; cout << c << endl; }//void Fun(int a,int b = 20,int c)//错误int main() { Fun(10); Fun(10,1); Fun(1,2,3); return 0; }

1. 半缺省参数必须从右往左依次来给出，并且不能间隔着给默认值
2. 缺省参数不能在函数声明和定义中同时出现（语法就是这样规定的），要么写在声明，要么写在定义，建议写在声明中
3. 缺省值必须是常量或者全局变量
4. C语言不支持（编译器不支持）

//函数重载 void f(char a) { cout << "f(char a)" << endl; }void f(int a) { cout << "f(int a)" << endl; }void f(int a,int b) { cout << "f(int a,int b)" << endl; }//顺序不同 void f(char b, int a) { cout << "f(char b,int a)" << endl; }

void fun(int a = 10) { cout << a << endl; }//不能构成重载 //void fun(int a) //{ // cout << a << endl; //}

//构成重载，但是存在问题 //修饰后的函数名_Z1F void F() { cout << "F" << endl; }//修饰后的函数名_Z1Fi void F(int a = 0) { cout << "F(int a)" << endl; }

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

int a = 10; //int& b; //错误 //引用在定义时必须进行初始化 int& b = a;

int a = 10; int& b = a; //一个变量可以有多个引用（可以有多个名字） int& c = a; int& d = a; int& e = b;

int a = 10; int& b = a; //引用一旦引用一个实体，就不能再引用其他实体 int i = 100; b = i; //这里只是把变量i的值给b，并不是让b成为i的别名

//址传递 //g++中修饰后的函数名为_Z4swappipi void swap(int* a,int* b) { //使用指针 int tmp = *a; *a = *b; *b = tmp; }//引用传递 //g++中修饰后的函数名为_Z4swapririr：reference引用 void swap(int& a,int& b) { //1.引用作为形参,a是实参x的别名，b是实参y的别名 //声明不会开空间，定义才会开空间 //定义引用时必须进行初始化，但是这里形参是声明，声明引用是不需要初始化的 int tmp = a; a = b; b = tmp; }//值传递 //g++中修饰后的函数名为_Z4swapii void swap(int a, int b) { int tmp = a; a = b; b = tmp; }//g++编译器中，三个函数修饰后的函数名不同，三个函数构成重载， //但是swap(x,y)；在调用时存在歧义， //类似之前学习的void f(); 和void f(int a = 10)；可以构成重载，但是调用时会存在歧义 //编译器不知道调用时传值还是传引用 int main() { int x = 10; int y= 20; swap(&x,&y); //swap(x,y); //有歧义，到底是值传递还是引用传递，会报错 return 0; }

typedef struct SLTNode { struct SLTNode* next; int data; }SLTNode,*SLT; //SLTNode的类型是struct SLTNode //SLT的类型是struct SLTNode*//指针的引用作为形参 //void SListInit(SLTNode*& phead) void SListInit(SLT& phead) { phead = NULL; }int main() { int a = 10; //b是a的引用 int& b = a; int* p1 = &a; //p2是p1的引用 int*& p2 = p1; SLTNode s; SLT ps= &s; SLT& p = ps; SListInit(p); return 0; }

void change(int* pi) { *pi = 100; }int main() { int a = 10; change(&a); std::cout << a << std::endl; return 0; }

void change(int& a) { a = 100; }int main() { int a = 10; //change(&a); change(a); std::cout << a << std::endl; return 0; }

int Add(int a,int b) { int c = a + b; //传值返回，实际返回的是c的一份临时拷贝 return c; }int main() { int ret = Add(10,20); std::cout << ret << std::endl; return 0; }

//引用传递返回 //但是会造成非法访问，函数调用结束后，栈帧销毁，c权限就返回给操作系统了 //我们再访问就是非法访问内存 int& Add(int a,int b) { int c = a + b; return c; //返回引用的意思就是不会生成c的拷贝返回，而是直接返回c的引用 }int main() { int& ret = Add(10,20); //ret和局部变量c的地址相同 //int ret = Add(10,20); //ret和局部变量c的地址不同 //cout也会调用栈帧 std::cout << ret << std::endl; //30 //栈帧销毁后，调用别的函数就会重复利用销毁的空间，内存是可以重复使用的 //但是只要不覆盖到上一次调用函数时存入栈帧的数据，就不会被改变 Add(1, 2); std::cout << ret << std::endl; //值可能为30，要看内存有没有清理、有没有被覆盖 return 0; }

int& Count() { //static修饰变量，存在静态区 static int n = 0； n++; // ... return n; }

typedef struct Stu { int age; char name[30]; }Stu; //指针做参数 void Func1(Stu* ps) {}//值传递 void Func2(Stu s) {}//引用做参数 void Func3(Stu& rs) {}

//引用作为返回值 int& fun(int i) { static int a[10]; return a[i]; //没有产生空间，只是产生了一个临时变量int& tmp } int main() { for (int i = 0; i < 10; i++) { fun(i) = 10 + i; } for (int i = 0; i < 10; i++) { std::cout << fun(i) << std::endl; } return 0; }

#include #include using namespace std; struct A { int a[10000]; }; //值传参 void TestFunc1(A a) {}//引用传参 void TestFunc2(A& a) {}void TestRefAndValue() { A a = { {0} }; // 以值作为函数参数 size_t begin1 = clock(); for (size_t i = 0; i < 10000; ++i) TestFunc1(a); size_t end1 = clock(); // 以引用作为函数参数 size_t begin2 = clock(); for (size_t i = 0; i < 10000; ++i) TestFunc2(a); size_t end2 = clock(); // 分别计算两个函数运行结束后的时间 cout << "TestFunc1(A)-time:" << end1 - begin1 << endl; cout << "TestFunc2(A&)-time:" << end2 - begin2 << endl; }int main() { TestRefAndValue(); return 0; }

int main() { const int a = 10; //a的值不能改变 //int& b = a; //权限放大，因为a是只读的，但是b是a的引用，b是可读可写的，把权限放大了，错误 const int& b = a; //正确，权限不变 int c = 20; //c可读可写 const int& d = c; //权限缩小，d只读，d是c的别名，d只读，是可以的 return 0; }

void f(int& x) { std::cout << x << std::endl; }int main() { const int a = 10; //f(a); //错误，因为a是只读的，但是f(int& x)中x是可读可写的,把权限放大了 //int& b = a; //错误，b把权限放大了 //f(b); return 0; }

void f(const int& x) { std::cout << x << std::endl; }int main() { const int a = 10; const int& b = a; //b是a的引用 f(b); //这里a,b,x共用一块空间 return 0; }

//对于指针，权限的放大、缩小，指的是const放在*的前面 int main() { const int* p1 = nullptr; int* p2 = nullptr; p1 = p2; //权限缩小 //p2 = p1; //错误，权限放大 //权限只能不变或者缩小，不能放大。 return 0; }

//使用常引用，在函数内部不能改变x的值 void f(const int& x) { std::cout << x << std::endl; }int main() { int a = 10; f(a); //权限缩小 const int b = 20; f(b); //权限不变 return 0; }

int main() { int a = 30; //相同类型没有隐式类型转换，不会产生临时变量 int& b = a; const int& b1 = a; double d = 3.14; int c = d; //隐式类型转换 //int& e = d; //错误 const int& f = d; //类型不一致，这里有隐式类型转换，会产生一个临时变量来存储结果，并不是直接把d的值给f，f引用的是临时变量，f是临时变量的引用，而临时变量是具有常属性的，所以引用变量f的类型和临时变量保持一致，所以应该是const int&，引用权限只能不变或者缩小。 return 0; }

f(a+c); //a+c会产生临时变量

int main() { int a = 1; int& b = a; int* p = &a; b = 2; *p = 3; return 0; }

1. 引用在定义时必须初始化，指针没有要求（但是最好初始化）
   
2. 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体
   
3. 没有NULL引用，但是有NULL指针
   
4. 在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占4个字节)
   
5. 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小
   
6. 有多级指针，但是没有多级引用
   
7. 访问实体方式不同，指针需要显式解引用，引用编译器自己处理，我们直接使用引用变量即可访问
   
8. 引用比指针使用起来相对更安全，指针使用起来更复杂、更不安全，指针要考虑空指针、野指针等。
   

void fun(int& a) { a = 20; }void f(int* p) { *p = 100; }int main() { //fun(0); //错误，形参是int&,但是0是const类型 //fun(NULL); //错误，没有空引用 int i = 10; fun(i); //f(NULL); //空指针不能进行解引用操作 //f(0); //0地址空间（也是空指针）我们没有权限访问 return 0; }

//写法1 #ifdef __cplusplus//c++内置的标识符，c没有 extern "C" { #endif; int add(int a,int b); #ifdef __cplusplus } #endif

//按照C语言编译规则来编译函数add extern "C" { int add(int a,int b); }

int add(int a,int b);

//写法2 #ifdef __cplusplus #define EXTERN_C extern "C" #else #define EXTERN_C #endifEXTERN_C int add(int a,int b);

int Add(int a,int b) { int c = a + b; return c; }int main() { int n = 10; int m = 20; int sum = Add(n,m); return 0; }

1. 在release模式下，查看编译器生成的汇编代码中是否存在call Add

2. 在debug模式下，需要对编译器进行设置，否则不会展开(因为debug模式下，编译器默认不会对代码进行优化)

1. inline是一种以空间换时间的做法，省去调用函数的开销。所以代码很长或者有循环/递归的函数不适合作为内联函数（短小的、频繁使用的函数建议设置成内联）。
   
2. inline对于编译器而言只是一个建议，编译器会自动优化，如果定义为inline的函数体内有循环/递归等等，编译器优化时会忽略掉内联。
   

1. 常量定义 换成用const
2. 函数定义 换成用内联函数

int main() { //auto：根据右边的值，自动去推导左边变量的类型 //a是整型 auto a = 10; //c是字符类型 auto c = 'w'; //typeid打印变量的类型 cout << typeid(a).name() << endl; //int cout << typeid(c).name() << endl; //char return 0; }

int main() { int a = 10; auto p = &a; auto* b = &a; auto c = a; auto& d = a; cout << typeid(p).name() << endl; //int* cout << typeid(b).name() << endl; //int* cout << typeid(c).name() << endl; //int cout << typeid(d).name() << endl; //int return 0; }

int main() { const int a = 0; auto b = 10; cout << typeid(b).name() << endl; //int int c = 20; auto d = c; cout << typeid(d).name() << endl; //int return 0; }

void Test() { auto a = 1, b = 2; auto c = 3, d = 4.0; // 该行代码会编译失败，因为c和d的初始化表达式类型不同 }

//auto不能作为形参类型，因为编译器无法对a的实际类型进行推导 void TestAuto(auto a) {}

void TestAuto() { int a[] = {1,2,3}; auto b[] = {4，5，6}; }

int main() { int arr[] = {1,2,3,4,5,6,7,8,9,10}; for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++) { cout << arr[i] << endl; //i的生命周期是整个循环 } return 0; }

int main() { int arr[] = {1,2,3,4,5,6,7,8,9,10}; for (int i : arr) { cout << i << endl; } return 0; }

int main() { int arr[] = {1,2,3,4,5,6,7,8,9,10}; for (auto i : arr) { cout << i << endl; } return 0; }

int main() { int arr[] = {1,2,3,4,5,6,7,8,9,10}; for (auto e : arr) { //局部变量e自身++，不会改变数组每个元素的值 e++; } for (int i : arr) { cout << i << endl; }//1 2 3 4 5 6 7 8 9 10 return 0; }

int main() { int arr[] = {1,2,3,4,5,6,7,8,9,10}; for (auto& e : arr) { //这里e的生命周期和C++98中i的生命周期不同 e++; //e的生命周期是一次循环 } return 0; }

//下面代码错误，for循环范围不知道 void TestFor(int array[]) { //array是指针 for(auto& e : array) cout<< e <

2. 迭代的对象要实现++和==的操作
对于这两点，以后再详细学习。
指针空值nullptr(C++11) C++98中的指针空值 在良好的C/C++编程习惯中，声明一个变量时最好给该变量一个合适的初始值，否则可能会出现不可预料的错误，比如未初始化的指针。如果一个指针没有合法的指向，它就是野指针，我们基本都是按照如下方式对其进行初始化：

void TestPtr() { int* p1 = NULL; int* p2 = 0; // …… }

在C++中，NULL实际是一个宏，查看其定义：

文章图片

可以看到，NULL可能被定义为字面常量0，或者被定义为无类型指针(void*)的常量。不论采取何种定义，在使用空值的指针时，都不可避免的会遇到一些麻烦，比如

void f(int) { cout << "f(int)" << endl; }void f(int*) { cout << "f(int*)" << endl; }int main() { f(0); //f(int) f(NULL); //f(int) f((int*)NULL); //f(int*) return 0; }

f(0)和f(NULL)都调用了f(int)函数，其实我们希望f(NULL)调用f(int*)，但是NULL定义成了0。在C++98中，字面常量0既可以是一个整形数字，也可以是无类型的指针(void)常量，但是编译器默认情况下将其看成是一个整形常量*，如果要将其按照指针方式来使用，必须对其进行强转(void *)0。所以在C++11中，引入了新的关键字nullptr作为空指针。
C++11中的空指针 注意
1.nullptr是C++11中引入的关键字，在使用nullptr表示指针空值时，不需要包含头文件；C语言中是没有nullptr的。
2.在C++11中，sizeof(nullptr) 与 sizeof((void*)0)所占的字节数相同。
【C++初阶|C++入门】3.为了提高代码的健壮性，以后表示指针空值时建议最好使用nullptr，不要使用NULL。

推荐阅读

• 

  婕珞芙晨露蔷薇面膜怎么样 婕路芙晨露蔷薇面膜可以分两次用吗
• 

  猪肉各部位的区别 猪肉哪个部位是一等肉
• 

  最早指南车发明人 指南车发明者
• 

  银天下行情分析系统软件下载
• 

  redis跳跃表查找数据的过程 redis哪块用到跳表
• 

  华为荣耀play3有没有指纹解锁（华为荣耀play3有指纹解锁吗）
• 

  amdk15支持什么cpu，amdk15主板支持的cpu
• 

  女性揉地筋的好处 主要有这些好处
• 

  汽车原厂互联映射什么意思
• 

  常年不在家冰箱怎么办？如何维护和保养？
• 

  怎样识别变频空调和定频空调 空调开一天多少钱
• 

  七绝（云水一梦惹东风）
• 

  新办企业个税申报密码 申报个税在哪个软件，企业个税能用手机申报吗
• 

  运动会通讯稿300字
• 

  美的SC861A吸尘器不充电的解决方法
• 

  刘海屏|iPhone 14强势曝光：是不是后悔手里的iPhone 13买早了？
• 

  iphone|从12999元跌至10488元，12G+512G，华为顶级旗舰现货供应不用抢购
• 

  绝地求生刺激战场国际服 绝地求生刺激战场国际服下载方法有哪些
• 

  无症状感染者会一直不发病吗
• 

  泰顺云雾茶是什么茶 泰顺雾云农庄

• 引用