C++基础知识

青旅半醒 2022-03-26 09:16 240阅读 0赞

一、命名空间  
使用命名空间的目的是对标识符的名称进行本地化，以避免命名冲突或名字污染。  
namespace关键字就是针对这种问题，起隔离的作用。  
（1）普通的命名空间

namespace N1  //N1为命名空间的名称
    {
    	//命名空间的内容即可以定义变量，也可以定义函数
    	int a;
    	int Add(int left, int right)
    	{
    		return left + right;
    	}
    }

（2）命名空间可以嵌套使用

namespace N2
    {
    	int a;
    	int b;
    	int Add(int left, int right)
    	{
    		return left + right;
    	}
    	namespace N3
    	{
    		int c;
    		int d;
    		int Add(int left, int right)
    		{
    			return left - right;
    		}
    	}
    }

（3）同一个工程中允许存在多个相同名称的命名空间

1、命名空间的使用

namespace bit
    {
    	const int N = 10;
    }

（1）加命名空间名称及作用域限定符

int main()
    {
    	printf("%d\n", bit::N);
    	return 0;
    }

（2）使用using将命名空间中成员引用

using bit::N;
    int main()
    {
    	printf("%d\n", N);
    }

（3）使用using namespace命名空间名称引用

using namespace bit;
    int main()
    {
    	printf("%d\n", N);
    }

二、C++的输入和输出  
cout标准输出，cin标准输入，endl为换行  
*注：不需要增加数据格式控制，比如：整性–%d，字符–%c*

#include<iostream>
    using namespace std;  //std为C++标准库的命名空间
    
    int main()
    {
    	int a;
    	double b;
    	char c;
    	cin >> a;
    	cin >> b >> c;
    	cout << a << endl;
    	cout << b << " " << c << endl;
    	return 0;
    }

三、缺省函数  
缺省参数：是声明或定义函数时为函数的参数指定一个默认值。在调用该函数时，如果没有指定实参则采用该默认值，否则使用指定的实参

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

1、缺省参数的分类  
（1）全缺省参数

void TestFunc(int a = 10, int b = 20, int c = 30)
    {
    	cout << "a = " << a << endl;
    	cout << "b = " << b << endl;
    	cout << "c = " << c << endl;
    }
    
    int main()
    {
    	TestFunc();           //10  20  30
    	TestFunc(1);          //1   20  30
    	TestFunc(1, 2);       //1   2   30
    	TestFunc(1, 2, 3);    //1   2   3
    	return 0;
    }

（2）半缺省参数

void TestFunc(int a, int b = 10, int c = 20)
    {
    	cout << "a = " << a << endl;
    	cout << "b = " << b << endl;
    	cout << "c = " << c << endl;
    }
    
    int main()
    {
    	TestFunc(1);          //1   10  20
    	TestFunc(1, 2);       //1   2   20
    	TestFunc(1, 2, 3);    //1   2   3
    	return 0;
    }

*注：1、半缺省参数必须从右往左依次来给出，不能间隔着给  
2、缺省参数不能在函数声明和定义中同时出现，一般放在声明中  
3、缺省值必须时常量或全局变量*

四、函数重载  
1、函数重载：同名函数的形参列表（参数的个数或类型或顺序）必须不同。

int Add(int left, int right)
    {
    	return left + right;
    }
    
    double Add(double left, double right)
    {
    	return left + right;
    }
    
    long Add(long left, long right)
    {
    	return left + right;
    }
    
    int main()
    {
    	Add(10, 20);
    	Add(10.0, 20.0);
    	Add(10L, 20L);
    	return 0;
    }

2、名字修饰  
C/C++中，一个程序运行起来，需经历：预处理、编译、汇编、链接。  
预处理：展开头文件、宏替换、条件编译、去掉注释…  
编译：检查语法错误、生成汇编代码  
汇编：把汇编代码转成二进制机器码  
链接：链接到一起，生成可执行程序

名字修饰是在编译过程中将函数、变量的名称重新改编  
而在C中，名字修饰规则特别简单，只是在函数名字前添加了下划线。  
因此当工程中存在相同函数名的函数时，会发生链接错误，就会产生冲突。故C中不适合函数重载。

3、extern “C”  
当工程中需要将某些函数按照C的风格来编译，在函数前加extern “C”

五、引用  
给已存在变量取了一个别名，与其引用的变量共用一块内存空间  
类型& 引用变量名（对象名）= 引用实体

void TeatRef()
    {
    	int a = 10;
    	int& b = a;
    	printf("%p\n", &a);
    	printf("%p\n", &b);
    }

1、引用特性：  
（1）引用在定义时必须初始化  
（2）一个变量可以有多个引用  
（3）一旦引用一个实体，再不能引用其他实体

void TestConstRef()
    {
    	const int a = 10;
    	//int& ra = a;    //该语句编译时会出错，a为常量，是不可改变的
    	const int& ra = a;
    	double d = 12.34;
    	//int& rd = d;    //该语句编译时会出错,类型不同
    	const int& rd = d;  //可行，在类型转换中产生了一个临时变量，这个临时变量是不可变的，即为const类型
    }

2、使用场景  
（1）做参数

void Swap(int& x, int& y)
    {
    	int tmp = x;
    	x = y;
    	y = tmp;
    }

（2）做返回值

int TestRefReturn(int& a)
    {
        	a += 10;
        	return a;
    }//当函数返回时，a所在的栈帧被销毁，a创建了一个临时空间，放在寄存器中保存，即传递了实参或返回变量的一份临时拷贝
    int& TestRefReturn(int& a)
    {
    	a += 10;
    	return a;
    }//当函数返回时，返回的对象不用拷贝

*注：1.返回对象是一个当前函数的局部变量，不能用引用返回  
2.返回对象出了当前函数的作用域依旧存在，可以用引用返回  
3.对象很大时尽量不要传值返回，使用传引用减少拷贝*

3、引用和指针的区别  
引用和指针的不同点：  
1）引用在定义时必须初始化，指针没有要求  
2）引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体  
3）没有NULL引用，但有NULL指针  
4）在sizeof中含义不同：引用结果为引用类型大小，但指针始终是地址空间所占字节个数  
5）引用自加即引用的实体加1，指针自加即指针向后偏移一个类型的大小  
6）有多级指针，但没有多级引用  
7）访问实体方式不同，指针需要显式解引用，引用编译器自己处理。  
引用在语法概念上是没有独立空间的，和其引用实体共用同一块空间。但在底层实现上实际是有空间的，因为指针是按照指针方式来实现的。  
8）引用比指针使用起来相对更安全

六、内联函数  
以inline修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开，没有函数压栈的开销，  
内联函数提升程序运行的效率

inline int Add(int x, int y)
    {
    	return x + y;
    }
    
    int main()
    {
    	int ret = 0;
    	ret = Add(1, 2);
    	return 0;
    }

inline是一种时间换空间的做法

C语言中使用宏函数  
宏函数  
优点：增强代码的复用性；提高性能  
缺点：不方便调试宏；导致代码可读性差，可维护性差，容易误用；没有类型安全的检查

#define ADD(a, b) ((a) + (b))
    #define SWAP(a, b) {int tmp;\
    	tmp = a;  \
        a = b;    \
        b = tmp; }
    #define SWAP(a, b) (a = (a) + (b), b = (a) - (b), a = (a) - (b));
    #define SWAP(a, b)\
    do
    {
    	int tmp = a; \
    		a = b;   \
    		b = tmp; \
    } while (false)

七、auto关键字  
auto作为一个新的类型指示符来指示编译器，auto声明的变量必须由编译器在编译时期推导而得

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

1、auto使用细则  
（1）auto与指针和引用结合起来使用  
用auto声明指针类型时，用auto和auto\*没有任何区别，但用auto声明引用类型时必须加&

int main()
    {
    	int x = 10;
    	auto a = &x;
    	auto* b = &x;
    	auto& c = x;
    	cout << typeid(a).name() << endl;
    	cout << typeid(b).name() << endl;
    	cout << typeid(c).name() << endl;
    	*a = 20;
    	*b = 30;
    	c = 40;
    	return 0;
    }

（2）在同一行定义多个变量（这些变量必须是相同类型的）

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

2、auto不能推导的场景  
（1）auto不能作为函数的参数  
此处代码编译失败，auto不能作为形参类型，因为编译器无法对a的实际类型进行推导

void TestAuto()
    {}

（2）auto不能直接用来声明数组

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

八、基于范围的for循环

void TestFor()
    {
    	int array[] = { 1, 2, 3, 4, 5 };
    	for (auto& e : array)
    	{
    		e *= 2;
    	}
    	for (auto& e : array)
    	{
    		cout << e << " ";
    	}
    }

*注：for循环迭代的范围必须是确定的。对于数组而言，就是数组中第一个元素和最后一个数组的范围。*

九、指针空值nullptr

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

NULL可能被定义为字面常量0，或者被定义为无指针类型(void\*)常量。  
故为避免混淆，用nullptr代表一个指针空值常量