102-C++学习第一弹(入门基础)

「爱情、让人受尽委屈。」 2022-12-29 02:29 7阅读 0赞

## C/C++ 的区别 ##

***1.输入输出***  
C语言下的输入输出

#include<stdio.h>
    int main()
    {
        
    	int a = 0;
    	char ch = '\0';
    	scanf("%d %c", &a, &ch);
    	printf("a = %d , ch = %c \n", a, ch);
    	return 0;
    }

C++下的输入输出

#include <iostream>
    using namespace std;
    int main()
    {
        
    	int a = 0;
    	char ch = '\0';
    	cin >> a >> ch;
    	cout << "a = " << a << "\t" << "ch = " << ch << endl;
    	return 0;
    }

在头文件iostream中定义有两个流类：输入流类istream和输出流类ostream,且用这两个类定义了流对象cin和cout  
cin是一个istream类的对象，它从标准输入设备(键盘)获取数据，程序中的变量通过流提取符“>>”从流中提取数据。流提取符“>>”从流中提取数据时通常跳过输人流中的空格、tab键、换行符等空白字符。注意：只有在输入完数据再按回车键后，该行数据才被送入键盘缓冲区，形成输入流，提取运算符“>>”才能从中提取数据。注意保证从流中读取数据能正常进行。  
cout是一个ostream类的对象，它有一个成员运算函数operator<<,每次调用的时候就会向输出设备输出。operator用运算符重载，可以接受不同类型的数据，如整型、浮点型、字符串甚至指针，等等。cout是标准输出设备，一般输出到屏幕。  
C++中的endl代表换行的意思

**C++的iostream与C的printf/scanf的区别**

1.  类型处理更安全、智能，printf中对付int、float等说明符比较麻烦
2.  扩展性更强，iostream使用的<<、>>操作符都是可重载，只要重载相关的运算符就可以；
3.  流风格的写法也比较自然简洁
4.  printf/scanf的速度比cin/cout快

***2.引用（别名）***  
*引用的定义*  
类型& 引用变量名称 = 变量名称;

这就是引用变量的定义。&和类型结合称之为引用符号，不是取地址的符，代表别名的意思。相当于给一个变量的名称取一个外号，两者都是指的是同一个变量。

int main()
    {
        
    	int a = 10;
    	int b = a;
    	int& d = a;
    	d+=10;//d是a的别名，通过对d的改变可以改变a值
    	const int& x = a;
    	//x是对a的别名，但是不能通过对x的改变改变a的值，因为x是常引用
    	return 0;
    
    }

引用特点：1.定义时不能空引用  
2.在声明引用时，必须给引用初始化（两点相辅相成）  
***引用与指针的对比***  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center]  
1.引用比指针使用起来方便  
2.使用指针要断言（assert）不为空，判空  
3.引用，没有空引用的概念，定义引用必须初始化，此程序的形参在调用时对它进行初始化。  
4.使用引用更加方便和安全，能用引用就尽量不要使用指针

***3.inline 函数（内联函数）***  
在 C++ 中，为了解决一些频繁调用的小函数大量消耗栈空间（栈内存）的问题，特别的引入了 inline 修饰符，表示为内联函数。

inline int Max(int a, int b)
    {
        
    	return a + b;
    }

内联函数的处理方式是在函数的调用点直接代码展开。在计算机系统下，假如频繁的调用就会造成较大的时间开销。内联函数的引入减少了函数调用过程中开栈和清栈的开销。处理流程如下图所示：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 1]  
左图普通函数调用点，函数的处理流程先进行实参压栈然后处理函数体。右图内联函数调用点，函数没有开辟和清栈，函数体直接在调用点代码展开。  
内联函数速度加快。典型的空间换时间。其实 inline 函数也不是十全十美的。如果一个项目下存在 N 多个 inline 函数的调用点。每个调用点都要将代码直接展开。会导致目标文件变得非常庞大。所有内联函数是以代码膨胀为代价的。典型的以空间换时间的概念来设计的。  
如果函数的执行开销小于开栈清栈开销，使用 inline 处理。这种情况下函数体较小，处理效率高。  
如果函数的执行开销大于开栈清栈开销，使用普通函数方式处理。这种情况下函数体较大，空间利用率高。特别是函数的执行开销远远大于开栈清栈开销。这种情况下函数开栈和清栈的开销就可以忽略不记。这种情况采用普通函数处理最合适。  
***内联函数和普通函数的区别***  
内联函数在调用点代码直接展开，没有开栈和清栈的开销。普通函数有开栈和清栈的开销。  
内联函数体要求代码简单，不能包含复杂的结构控制语句。  
如果内联函数函数体过于复杂，编译器将自动把内联函数当成普通函数来执行。  
***内联函数和 static 修饰的函数的区别***  
static 修饰的函数处理机制只是将函数的符号变成局部符号，函数的处理机制和普通函数相同，都有函数的开栈和清栈开销。内联函数没有函数的开栈和清栈函数  
inline 函数是因为代码在调用点直接展开导致函数本文件可见。而 static 修饰的函数是因为函数符号从全局符号变成局部符号导致函数本文件可见。  
***内联函数和宏的区别***  
inline 函数的处理时机是在编译阶段处理的，有安全检查和类型检查。而宏的处理是在预编译阶段处理的。没有任何检查机制，只是简单的文本替换。  
inline 函数是一种更安全的宏  
***从汇编层次来看*** Inline 函数调用明显是以实参压栈的方式来处理的。有开栈和清栈的开销产生。这是为什么呢？  
其实 inline 函数也有一些限制。  
1.inline 函数一般写在头文件中  
2.inline 函数只在 Release 版本生效。在 Debug 版本是不生效。  
3.inline 函数只是给编译器的一个建议。具体是否处理成 inline 函数是编译器决定的。基于实现的，不是基于声明。（如函数有循环，函数块过大）

***4.函数参数的默认值***  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 2]  
注意：1.C++可对参数给默认值，必须从右往左初始化，不能跳跃着给。  
2.fun(1,2,3,(1,2,3,4),4,5)，当括号的括号里有多个参数时，默认为最右边的数。  
3.fun(12, ,34);也是错误的,逗号前面必须要有实参  
4.调用函数从左向右fun(12,23,34) 后两个为默认值

***5.函数的重载***  
C中区分函数靠函数名。C++区分函数靠函数的原型 包括函数返回类型、函数名、形参列表（其中形参名可以省略），且不需要函数体。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 3]  
9-11行的这个过程是在编译的时候确定的。  
函数重载不能出现二义性。返回类型虽然不同，但是调用的时候会造成混乱。返回类型不能作为函数重载的依据。意义不明确。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 4]  
***C++重载的判断依据***

1.  函数形参的个数
2.  函数形参的类型
3.  形参的顺序
4.  不能把返回值作为函数重载的条件，原因是编译器在编译时不会去判断函数的返回类型，函数只有调用后，编译器才会去验证返回类型，所以返回值不能作为函数重载的依据。
5.  常函数 const 可以作为函数重载判断依据，原因：重载\[\]运算符时，有没有const的区别是：有const只读，没有const读写都可以。

***C++中的函数名称粉碎机制***  
在C语言的语法中，函数名称是一个函数的唯一标识，如果一个文件内含有两个名称相同的函数，编译器就会报“函数已有主体”的错误；在多个文件链接时，如果发现有两个名称相同的函数，链接器就会报“符号重定义”的错误。具有多态特性的C++支持函数的重载，函数不再以函数名称作为唯一标识。只要满足构成重载的条件，两个（或多个）功能不同的函数可以有相同的函数名称。这样一来，函数的调用者会获得多态性带来的极大方便（虽然函数的编写者的工作量没有改变，所有的同名函数仍需要一个一个地去编写）。构成函数重载的条件是：  
1.作用域相同  
2.函数名称相同  
3.参数不同(类型,个数,顺序)  
（另外：返回值类型、调用约定类型并不作为参考）  
为了支持函数重载这一新特性，编译器的开发者们大多选择使用名称粉碎机制，即把函数的原有名称和参数类型、个数、顺序等信息融合成一个新的函数名称。这个新的名称就是此函数的唯一标识。有了它，之后的工作就可以继续沿用C语言的套路（在编译、连接过程中，若发现新名称存在重复现象，仍会发出“函数已有主体”或“符号重定义”信息）。  
值得一提的是，C++标准中只是说明了函数重载的定义，但并没有提出“名称粉碎机制”这种概念。由于名称粉碎机制的直观、高效、易于兼容以前的C版本的特点，所以各编译器作者不约而同地选择用名称粉碎机制来实现函数重载。虽然各编译器的思路是一致的，但是由于没有统一的标准，所以各编译器的名称粉碎结果也自然是五花八门。

***6.模板函数***  
函数模板定义如下：  
template<模板参数表>  
返回类型 函数名(形式参数表) \{  
//函数体  
\}<模板参数表>（template parameter list）尖括号中不能为空，参数可以有多个，用逗号分开。  
模板参数主要是模板类型参数,也可以是非类型。

template<class Type>
    const Type& Max(const Type& a, const Type & b)
    {
        
    	return a > b ? a : b;
    }
    
    int main()
    {
        
        char ch = Max('a', 'b');
    	int x = Max(12, 23);
    	double dx = Max(12.23, 34.45);
    	return 0;
    }

模板类型参数(template type parameter)代表一种类型，由关键字 class 或 typename（建议用 typename ）后加一个标识符构成，在这里两个关键字的意义相同，它们表示后面的参数名代表一个潜在的内置或用户设计的类型。函数模板根据一组实际类型或（和）值构造出独立的函数的过程通常是隐式发生的，称为模板实参推演(template argument deduction)。

***来源***  
这部分在编译的时候展开，系统先看到这是个模板函数，然后看到Max，看到char类型，编译器看到这是模板函数，生成了处理char类型的typedef char T，处理char的函数。接着看到int类型，根据推演。生成下一个代码 int类型的。T被重命名整型，Max处理整型。接着看到double，T被重命名double，编译的生成一个函数，处理double。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 5]  
这三个函数生成了，再依次进行编译，分别生成处理char,int,double的代码，形成之后，编译运行后与具体的代码挂接起来。  
**模板函数是生成函数的一种特性，在编译时，根据实参推演出形参的类型，产生这些函数。**  
也可以越俎代庖。  
![在这里插入图片描述][20201219211227736.png_pic_center]  
***7.new/delete 和 malloc/free 区别***  
在 C++中堆内存的分配和释放是通过 new 和 delete 来操作的。使用方式如下  
开辟内存： 类型\* 指针变量名 = new 类型(初始化数值);  
释放内存： delete 指针变量名；

int main()
    {
        
    	int* p = new int(10);
    	*p = 100;
    	delete p;
    
    	p = new int[10];
    
    	delete[] p;
    
    }

***new 与 malloc 的区别***  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 6]

1.malloc开辟空间是函数，需要引用<stdlib.h>头文件  
new是关键字  
2.malloc开辟空间返回无类型指针，需要强转  
new 是int类型的空间  
3.malloc 要计算类型的大小  
new int类型的大小是自动进行计算的  
4.malloc只是开辟空间  
new 也开空间 还给开的空间初始化 初始化为1  
5.malloc申请空间失败的时候，返回空指针  
new申请空间失败 throw bad-alloc（坏的内存分配）

**delete p;**  
只是把p指向的空间还给系统（释放内存），并没有把指针p本身删除  
p在主函数的栈区

int \*p=new int\[n\]; //数组，开辟n个整型空间，连续空间 , delete\[\]p;  
int \*p=new int(n);//对每一个整型空间初始化为n  
int \*p=new int\[n\] (10) //要看编译器是否可以识别

new 的三种调用规则  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 7]  
operator new 和 malloc都是函数，唯一区别，operator new 失败 throw bad-alloc malloc 返回空指针  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 8]  
第一种效果 和 第二种第三中合起来的效果 一样。  
new 初始化  
operator 不能初始化 随机值

delete pa ;  
operator delete(pb);  
删不了 pa pb  
只是把指向的空间还给系统  
导致pa pb 变成空悬指针（不安全）  
释放后要将指针置空！！！  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 9]  
delete后，p仍然保留着原来的地址  
仍然可以获取值，是随机值。  
也可以修改。系统没有对已经释放的空间进行保护。

***8.namespace 名字空间作用域***  
为了解决命名冲突的问题，C++提供了名字空间作用域的机制。  
namespace 名字空间作用域名称  
\{ \}  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 10]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 11]

using 指示符是将 using 指示符后名字空间作用域下的所以符号暴露在 using 指示符所在的作用域。因为 using 指示符会导致名字空间作用域被污染。所以我们在编码过程中并不提倡使用 using 指示符。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center]: /images/20221120/715fcedfea544a2aa6860e1b8ce0592e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 1]: https://img-blog.csdnimg.cn/2020121920270742.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY=,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 2]: https://img-blog.csdnimg.cn/20201219203626978.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY=,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 3]: https://img-blog.csdnimg.cn/20201219204044284.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY=,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 4]: https://img-blog.csdnimg.cn/20201219205143502.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY=,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 5]: https://img-blog.csdnimg.cn/20201219210750701.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY=,size_16,color_FFFFFF,t_70#pic_center
[20201219211227736.png_pic_center]: https://img-blog.csdnimg.cn/20201219211227736.png#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 6]: https://img-blog.csdnimg.cn/20201219212012414.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY=,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 7]: https://img-blog.csdnimg.cn/20201219213639511.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY=,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 8]: https://img-blog.csdnimg.cn/20201219213901249.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY=,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 9]: https://img-blog.csdnimg.cn/20201219214626819.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY=,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 10]: https://img-blog.csdnimg.cn/20201219215215620.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY=,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 11]: https://img-blog.csdnimg.cn/20201219215437130.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY=,size_16,color_FFFFFF,t_70#pic_center