【C++那些事】C++入门 |命名空间 |相关参数引用 |内联函数 |自动 | 关键字循环范围 | nullptr 原创

void  TestRef(){ int a = 10;int& ra = a;//<====定义引用类型printf("%p\n", &a);printf("%p\n", &ra) ;}

void TestRef(){int a = 10;// int&ra; // 该条语句编译时会出错int& ra = a;int& rra = a;printf("%p %p %p\n"， &a， &ra, &rra);}

void TestConstRef< /span>(){const int a = 10;// int& ra = a; // 该语句编译时会出错，a为常量const int& ra = a;// int& b = 10; // 该语句编译时会出错，b为常量const int& b = 10;双 d = 12.34;// int& rd = d; // 该语句编译时会出错，类型不同const int& rd = d; //用隐式类型转换会产生临时变量，临时变量常性< /span>}

void 交换(int& 左，  int& 右){int temp = left;左 = 右;右 = temp;}

int& 计数(){静态 int n = 0;n++;// ...返回 n; }

int& 添加< span class="a0dc-afb8-c9ac-02d3 token punctuation">(int a， int b){int c = a + b;返回 c;}int main( ){int< span class="f403-a234-2c2f-8875 token 操作符">& ret = 添加(1, 2);添加( 3, 4);cout << "添加(1, 2) 是:" << ret << endl;返回 0;} 

#包括 struct A { int a[10000]; };void TestFunc1(A a) {}void TestFunc2(A& a) {}void TestRefAndValue(){A a;//以值作为函数参数size_t begin1 = clock();用于 (size_t i = 0; i < 10000; ++i)TestFunc1(a);size_t end1 =  时钟();//以引用作为函数参数size_t begin2 = 时钟();for (size_t i =0; i < 10000; ++i)TestFunc2(a);size_t end2 = 时钟();//分别计算两个函数运行结束后的时间cout << "TestFunc1(A)-时间：" << end1 - begin1 << endl;cout << "TestFunc2(A&)-时间：" << end2 - begin2 << endl;}int main< span class="a234-2c2f-8875-5409 token punctuation">(){TestRefAndValue(); 返回 0;}

#include  struct A { int a[10000 span>]; };A a;//值返回A TestFunc1() { 返回 a; }void TestReturnByRefOrValue (){< /span>//以值作为函数的返回值类型size_t begin1 = 时钟();for (size_t i = 0; i < 100000; ++i)TestFunc1();size_t end1 = 时钟();//以引用作为函数的返回值类型size_t begin2 = 时钟();对于 (size_t i = 0; i < 100000; ++i )TestFunc2();size_t end2 = 时钟 ();// 计算两个函数侵犯完成之后的时间cout << "TestFunc1 time:" << end1 - begin1 << endl;cout << "TestFunc2 时间："< /span> << end2 - begin2 << endl ;}int main(){int a = 10;int& ra = a;cout << " &a = " << &a << endl;cout << "&ra = " << &ra << endl;返回< /span> 0;}< /pre> 
 
在底层实现上实际上是有空间的，因为引用是按照剪刀方式来实现的。
 
int main(){int a = 10;< span class="afb8-c9ac-02d3-f403 token 关键字">int& ra = a;ra = 20;int* pa = &a;*pa = 20;返回 0;}
 
我们查看下引用和指针的裁剪代码对比：
 
 
< code>引用和指示器的不同点
引用概念上定义了一个变量的别名，指示器存储一个变量地址。引用在定义时必须初始化，指针在初始化时没有要求引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体没有NULL引用，但有NULL指针在sizeof中映射不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节数(32位平台下占4个字节)引用自加即引用的实体增加1，指针自加即指针移动移动一个类型的大小多少级指针，但是没有多级引用访问实体方式不同，指针需要显式解引用，引用编译器自己处理 引用比指针使用起来相对更安全 
7.内联函数
 
PS：头文件中定义一个函数，如果该头文件在多个位置被包含，那么就会出现函数重定义的问题，编译器报错，那么这个问题就解决呢？
 
有清晰的方法：
 
声明和定义分离（防止链接冲突）
 只在头文件中进行函数声明，而不是函数定义。然后，在源文件中实现这个函数。这样，​​即使头文件被多次包含，也不会出现重定义的问题。
 
static静态函数，链接属性，只在当前文件可见
在C++中，可以将函数定义为静态的。这意味着函数只在定义它的文件内部可见（底层就是这个函数不会进符号表，不能声明和定义分离）。这样，即使函数在多个文件中被包含，也不会出现重定义的问题。
 
内联内联函数（不能声明和定义分离）
 原理与静态相似，函数不进符号表
 
7.1概念
 
以内联修饰的函数调用内联函数，编译时C++编译器会在调用内联函数的地方展开，没有函数调用建立栈帧的开销，内联函数提升程序运行的效率。
 
 
如果在上述函数前增加内联关键字将其改成内联函数，在编译期间编译器会用函数体替换函数的调用。
 
查看方式： 在release模式下，查看编译器生成的编译器代码中是否存在call Add，在debug模式下，需要对编译器进行设置，否则不会展开(因为debug模式下，编译器默认不会对代码进行优化，以下给出vs2023的设置方式） 

 
 
 
7.2特性
 inline是一种以空间替换时间的做法，如果编译器将函数当成内联函数处理，在编译阶段，会用函数体替换函数调用，缺陷：可能会使目标文件变大，优势：少了一笔开销，提高程序运行效率。内联对于编译器来说只是一个建议，不同的编译器关于内联实现机制可能不同，一般建议：将函数规模更小小(即函数不是很长，具体没有准确的说法，依赖编译器内部实现)、不是多层、且多重调用的函数采用内联修饰，否则编译器会忽略内联特性。下图为
 《C++prime》第五版关于内联的建议：
内联不建议声明和定义分离，分离会导致链接错误。因为内联被展开，就没有函数地址了，链接就会找不到。 
// F.h#include 使用 命名空间 std;内联 void f(int i) ; //无函数地址// F.cpp #include  "F.h"void f(int i){cout << i << endl ;}// main.cpp#包括 "F.h"int main() {f(< /span>10);返回 0;}/ * 链接错误：main.obj : error LNK2023: 无法解析的外部符号 "void __cdecl f(int)" (?f@@YAXH@Z)，该符号在函数 _main 中被引用 */
 
【面试题】
 
宏的优缺点？
 
优点：
 增强代码的复用
缺点：
 不方便调试宏。（因为预编译阶段进行了替换）导致代码存在性差，可维护性差，容易误用。没有类型安全的检查 。 
C++ 有哪些技术替代宏？
 常量定义换用 const enum短小函数定义换用内联函数\ 
8.关键字 auto(C++11)
 
8.1 类型别名思考
 
随着程序越来越复杂，程序中用到的类型也越来越复杂，经常体现在：
 类型难于拼写暗示不明显导致容易出错 
#包括 <字符串>< /span>#include int main(){std::map<std::string, std::字符串> m{ { "apple", "苹果" },{ "橙色", "橙子" }, {"pear","梨"} }; std::map<std::string, std::string>::迭代器 = m。开始();while (它!= m。结束()){//....}返回 0;} 
 
std::map::iterator 是一个类型，但是该类型太长了，特别容易写错。聪明的同学可能已经想到：可以通过 typedef给类型取别名，比如：
 
#包括 #包括 typedef std::map<std::字符串, std::字符串< span class="a0dc-afb8-c9ac-02d3 token 运算符">> 映射;int main(){映射 m{  { "苹果", "苹果" },{ "橙子", "橙子"< /span> }, {"梨","梨"} };地图::迭代器 = m.开始();同时 (it != m.结束())< span class="fcf9-2078-7169-8a0f token punctuation">{//....}< /span>返回 0;}
 
使用 typedef 给类型取别名确实可以简化代码，但是 typedef 又会遇到达新的问题：
 
typedef char* pstring;int main(){const pstring p1< span class="8a0f-a0dc-afb8-c9ac token punctuation">; //编译成功还是失败？const pstring* p2; //编译成功还是失败？返回 0;}< /span>
 
 
bebe代码中，const pstring p1; 和 const pstring* p2; 的编译失败。
 
在C++中，const关键字用于声明常量，表示该变量的值不能被改变。但是，const关键字也可以用于修饰指针。当const关键字放置星号()前面时，它表示指针本身是常量，即不能改变指针指向的位置；当const关键字放置星号()后面时，它表示指针指向的内容是常量，即不能通过该指针改变所指向的内容。
 
在猜测代码中，const pstring p1;< /code> 尝试定义一个常量指针p1，没有初始化，这是不允许的。同样，const pstring* p2;尝试定义一个指向常量指针指针的指针p2，但是也没有初始化。，这行代码都会引发编译错误。
 
 
在编程时，通常需要把表达式的值赋值给变量，这就要求在声明变量的时候清楚地知道表达式的类型。然而有时要做到这并不那么容易，因此 C++11 给 auto 赋予了新的含义。
 
8.2汽车简介
 
C++11中，标准委员会赋予了汽车全新的含义即：汽车不再是一个存储类型指示符，而是作为一个新的类型指示符来指示编译器，汽车声明的信号必须由编译器在编译期推导而得。
 
int< /span> TestAuto(){返回 10;}int main< /span>(){int a = 10;auto b = a;< /span> // 类型为 intauto c = 'a'; //类型为char//int(*pf)() = TestAuto;auto pf = TestAuto; // 类型为 int(*)()auto d = TestAuto(); //类型为 int// typeid().name 打印变量类型cout << typeid(b)。名称( ) << endl; cout << typeid(c).名称() << endl;cout <<  typeid(pf)。名称()< /span> << endl;cout << < span class="02d3-f403-a234-2c2f token keywords">typeid(d)。名称()  << endl;//auto e;无法通过编译，使用自动定义变量时必须对其进行初始化return 0;}
 
 
【注意】
 
使用 auto 定义变量必须在其进行初始化时，在编译阶段编译器需要根据初始化表达式来推导 auto 的实际类型。因此 auto 不是一种“类型”的声明，而是一个类型声明时的“占位符”，编译器在编译期将自动替换为变量实际的类型。
 
8.3 auto的使用细则
 auto与指针和引用结合起来使用
 用auto声明指针类型时，用auto和auto*没有任何区别，但用auto声明引用类型时则必须加&< /mark>
 在同一行定义多个变量
 当在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器将会报错，因为编译器实际上只对第一个类型进行推导，然后用推导出来的类型定义其他变量。 
void TestAuto(){ auto a = 1, b = 2; auto c = 3, d = 4.0; //行行代码会编译失败，因为c和d的初始化表达式类型不同}
 
< /p> 
8.3 auto 不能推导的场景
 auto 不能作为函数的参数 
//此处代码编译失败，auto不能作为形参类型，因为编译器对无法a的实际类型进行推导void TestAuto( auto a){ }
 auto不能直接声明用于仓库 

 3.为了避免与C+ +98中的自动发生语法，C++11只保留了auto类型指示符的用法
4. auto在实际中最常见的优势用法就是跟以后会讲到C++11提供的循环新式，还有lambda表达式等进行殴打。
 
 
9.基于范围的for循环(C++11)
 
9.1范围for的语法
 
在C++98中如果要访问一个数据库，可以按照以下方式进行： 
void TestFor(){ int 数组[] = { 1, 2, 3, 4< span class="a234-2c2f-8875-5409 token punctuation">, 5 } ; for (int i = 0; i  < sizeof(数组) / sizeof(数组[0]); ++i) 数组[i] *= 2;< /span> for (int* p = 数组; p < 数组 + sizeof(array) / sizeof(数组[0]); ++p) cout << *p < < endl;}int main(){ TestFor(); 返回 0 ;}
 

 对于一个有范围的集合方面，由程序员来说明循环的范围是多余的，有时还会很容易犯错误。因此C++11中引入了基于范围的for循环。for循环后的范围逗号由冒号“ ：”分为两部分：第一部分是范围内用于迭代的变量，第二部分则表示被迭代的范围。
 
void TestFor(){ int 数组[] ={ 1, < span class="4bf8-41c3-db03-fcf9 token number">2, 3 , 4, 5 }; 对于 (< /span>auto& e : array) e *= 2 ; for (auto e : array) cout << e << endl;}int main(){ TestFor() ; 返回 0;}
 

 注意：与普通循环类似，可以用 continue 来结束本次循环，也可以用 break 来跳出整个循环。
 
9.2 的使用范围条件
 
1.对于循环迭代的范围必须是确定的
 
对就吞吐量而言，就是吞吐量中第一个元素和最后一个元素的范围；对于类而言，应该提供begin和end的方法，begin和end就是循环迭代的范围。
 
注意：以下代码存在问题，因为范围不确定
 
//确定的参数是阵列的首地址，无法获取阵列的大小void TestFor(int 数组[] ){ 对于< span class="fcf9-2078-7169-8a0f token punctuation">(auto& e : 数组) cout<< e <<< /span>endl;}
 
2.迭代的对象要实现++和==的操作。
 
 
10.指针空值nullptr(C++11)
 
10.1 C++98中的指针空值
 
在良好的C/C++编程习惯中，声明一个变量时最好给该变量一个正确的初始值，否则可能会出现不可预料的错误，比如未初始化的我们的指针。如果一个指针没有合法的指向，基本都是按照如下方式进行初始化：
 
void TestPtr( ){ int< /span>* p1 = NULL; int* p2 =< /span> 0; // ……}
 
NULL 实际上是一个宏，在传统的C头文件(stddef.h)中，可以看如下代码：
 
#ifndef NULL #ifdef __cplusplus # 定义 NULL 0  #else< /span> #定义 NULL (( void *)0) # endif#< span class="2078-7169-8a0f-a0dc tokendirectivekeyword">endif
 

 可以看到，NULL 可能被定义为字面常量0，或者被定义为无类型指针(void*)的常量。必须采取一定的定义，在使用空值的指针时，都会遇到一些麻烦，比如：
 
 void f(int){ cout << "f(int)" << endl;}void f(int*)< span class="afb8-c9ac-02d3-f403 token punctuation">{ cout << "f(int* )" << endl;} int main() { f(< span class="8a0f-a0dc-afb8-c9ac token number">0);  f(NULL); f((< /span>int*)NULL); 返回 0;}
 

 程序本意是想通过f(NULL)调用指针版本的f(int*)函数，但是由于NULL被定义成0，因此与程序的初衷相悖。
 
在C++98中，字面常量0既可以是一个整形常量，也可以是无类型的指针(void*)常量，但是编译器默认情况下将其看成是一个整形常量，如果推断其按照指针方式来使用，必须此处进行强转(void *)0。
 
注意：
 在使用nullptr表示指针空值时，不需要包含头文件，因为 nullptr 是C++11作为新关键字引入的。在C++11中，sizeof( nullptr) 与 sizeof((void*)0) 所占的字节数相同。为了提高代码的健壮性，在后续表示指针空值时建议最好使用 nullptr。