C++入门

Latecomessnow

已于 2022-08-07 10:57:24 修改

阅读量522

点赞数

文章标签： c++ 开发语言经验分享

于 2022-08-02 10:37:33 首次发布

本文链接：https://blog.csdn.net/qq_53117983/article/details/126098084

版权

1、命名空间

1.1 为什么使用命名空间

在C/C++中，变量、函数和类都是大量存在的，这些变量、函数和类的名称将都存在于全局作用域中，可能会导致很多冲突。使用命名空间的目的是对标识符的名称进行本地化，以避免命名冲突或名字污染，namespace关键字的出现就是针对这种问题的。

如下图所示：

我们知道程序首先会在局部变量去寻找rand这个变量，在局部变量中没有找到这个变量后，再去全局变量中寻找rand这个变量，而rand在C/C++的库中是一个函数，此处我们又定义了rand一个全局变量就会发生重定义而导致报错。如果执意把rand函数打印出来，可以看到打印出来的是rand函数的地址。

上述问题反映出了当变量命名与库函数中的命名冲突时程序是无法正常运行的，当不同文件中存在相同的变量时也是会报变量重定义的错误，如下图所示。

C语言没办法解决类似这样的命名冲突问题，所以C++提出了namespace来解决。

1.2 命名空间的定义

定义命名空间，需要使用到namespace关键字，后面跟命名空间的名字，然后接一对{}即可，{}中即为命名空间的成员。

//1. 正常的命名空间定义
namespace test
{
	// 命名空间中可以定义变量/函数/类型
	int rand = 10;
	int Add(int left, int right)
	{
		return left + right;
	}
	struct Node
	{
		struct Node* next;
		int val;
	};
}

//2. 命名空间可以嵌套
// test.cpp
namespace N1
{
	int a;
	int b;
	int Add(int left, int right)
	{
		return left + right;
	}
	namespace N2
	{
		int c;
		int d;
		int Sub(int left, int right)
		{
			return left - right;
		}
	}
}

//3. 同一个工程中允许存在多个相同名称的命名空间,编译器最后会合成同一个命名空间中。
// ps：一个工程中的test.h和上面test.cpp中两个N1会被合并成一个
// test.h
namespace N1
{
	int Mul(int left, int right)
	{
		return left * right;
	}
}

注意：一个命名空间就定义了一个新的作用域，命名空间中的所有内容都局限于该命名空间中。

1.3 命名空间的使用

1. 命名空间名称后加上域作用限定符，域作用限定符为“::”。

namespace N
{
	int rand = 10;
}

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

此时我们就可以看到rand不会与库中的rand函数冲突了。

2. 使用using将命名空间中某个成员引入，这样将命名空间中的成员变量展开之后，在使用变量时就不需要加上域作用限定符了。如下所示。

namespace N1
{
	int a = 10;
}

namespace N2
{
	int b = 20;
}

using N2::b;

int main()
{
	printf("%d\n", N1::a);
	printf("%d\n", b);
}

3. 使用using namespace 命名空间名称引入，这样就是把命名空间中的所有成员展开了，也不需要在变量前加上域作用限定符了。

namespace N
{
	int a = 10;
	int b = 0;
	char c = 'a';
}

using namespace N;

int main()
{
	printf("%d\n", a);
	printf("%d\n", b);
	printf("%c\n", c);
}

2、C++输入&输出

想必大家无论学习哪一种语言，第一个写的程序都是hello world吧，哈哈哈，我们来看一下C++版的hello world吧。

#include<iostream>
// std是C++标准库的命名空间名，C++将标准库的定义实现都放到这个命名空间中
using namespace std;
int main()
{
	cout << "Hello world!" << endl;
	return 0;
}

1. 使用cout标准输出对象(控制台)和cin标准输入对象(键盘)时，必须包含< iostream >头文件以及按命名空间使用方法使用std。

2. cout和cin是全局的流对象，endl是特殊的C++符号，表示换行输出，他们都包含在< iostream >头文件中。

3. <<是流插入运算符，>>是流提取运算符。

4. 使用C++输入输出更方便，不需要像printf/scanf输入输出时那样，需要手动控制格式。C++的输入输出可以自动识别变量类型。

count << "hello world!"此处可以按照其箭头所指大致理解成把“<<"后的输出对象插入到控制台中，再显示到显示器上。

cin >> a则表示从键盘输入的值放到缓冲区后，利用流插入提取运算符“>>”提取到a这个变量，也就是赋值给a。

#include<iostream>

using namespace std;

int main()
{
	int a;
	double b;
	char c;
	// 可以自动识别变量的类型
	cin >> a;
	cin >> b >> c;
	cout << a << endl;
	cout << b << " " << c << endl;
	return 0;
}

3、缺省参数

C语言中并没有缺省参数，C++中加入了这一特性，缺省参数是声明或定义函数时为函数的参数指定一个缺省值。在调用该函数时，如果没有指定实参则采用该形参的缺省值，否则使用指定的实参。如下图。

缺省参数分类：

1. 全缺省参数：

void Func(int a = 10, int b = 20, int c = 30)
{
 cout << "a = " << a << endl;
 cout << "b = " << b << endl;
 cout << "c = " << c << endl;
}

2.半缺省参数：

void Func(int a, int b = 10, int c = 20)
{
 cout << "a = " << a <<endl;
 cout << "b = " << b <<endl;
 cout << "c = " << c <<endl;
}

注意：

1. 半缺省参数必须从右往左依次来给出，不能间隔着给

2. 缺省参数不能在函数声明和定义中同时出现

3. 缺省值必须是常量或者全局变量

4. C语言不支持（编译器不支持）

一般缺省参数在函数声明中，也就是头文件中给就可以了，声明中给了缺省参数，函数定义中就不需要再给缺省参数了。

//a.h
void Func(int a = 10);
// a.cpp
void Func(int a = 20)
{}
// 注意：如果生命与定义位置同时出现，恰巧两个位置提供的值不同，那编译器就无法确定到底该用那
个缺省值。

4、内联函数

概念：以inline修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开，没有函数调用建立栈帧的开销，内联函数提升程序运行的效率。

如上图所示可以看到没有加inline修饰的函数在编译链接时会直接调用函数，而函数的调用会创建函数栈帧有空间的消耗，如果在上述函数前增加inline关键字将其改成内联函数，在编译期间编译器会用函数体替换函数的调用，如果编译器将函数当成内联函数处理，在编译阶段，会用函数体替换函数调用。内联函数少了调用开销，提高程序运行效率，但可能会使目标文件变大，是一种以空间换时间的做法。

注：inline不建议声明和定义分离，分离会导致链接错误。因为inline被展开，就没有函数地址了，链接就会找不到。

5、auto关键字(C++11)

5.1 auto简介

一般程序中会有内置类型和自定义类型，内置类型就是C/C++中的“int、char、double……”，而自定义类型就是struct和class出来的类型，面对自定义类型时，我们会碰到一些比较复杂的类型，会遇到类型太长、类型难以拼写等等问题，这是我们可能会想到typedef重命名，但是遇到如下程序时，typedef是否还能行得通呢？

typedef char* pstring;
int main()
{
 const pstring p1; // 编译成功还是失败？
 const pstring* p2; // 编译成功还是失败？
 return 0;
}

可以试试。

在早期C/C++中auto的含义是：使用auto修饰的变量，是具有自动存储器的局部变量，C++11中，标准委员会赋予了auto全新的含义即：auto不再是一个存储类型指示符，而是作为一个新的类型指示符来指示编译器。

auto可以自动识别变量的类型，但需要注意的是auto定义变量时一定要初始化，如下所示：

int TestAuto()
{
	return 10;
}

int main()
{
	int a = 10;
	auto b = a;
	auto c = 'a';
	auto d = TestAuto();
	cout << typeid(b).name() << endl;
	cout << typeid(c).name() << endl;
	cout << typeid(d).name() << endl;
	//auto e; 无法通过编译，使用auto定义变量时必须对其进行初始化
	return 0;
}

注：使用auto定义变量时必须对其进行初始化，在编译阶段编译器需要根据初始化表达式来推导auto的实际类型。因此auto并非是一种“类型”的声明，而是一个类型声明时的“占位符”，编译器在编译期会将auto替换为变量实际的类型。

5.2 auto使用细则

1. auto可以与指针和引用结合使用，如auto* xxx 和 auto& xxx，但值得注意的是auto和auto*并无区别，后者只是为了突出变量是个指针，使用auto声明引用类型时则必须要加“&”。

2. 当使用auto在一行代码上定义多个变量时，auto只会使用在该行上第一个推导出来的auto的类型，然后使用推导出来的类型去定义该行上的其他变量。如如下代码将会报错：

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

此时将会报“auto”必须始终推导为同一类型的错误，那么会造成d可能是int也可能是double类型。

5.3 不能使用auto的场景

1. auto不能作为函数的参数

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

注：为了避免与C++98中的auto发生混淆，C++11只保留了auto作为类型指示符的用法。auto在实际中最常见的优势用法就是跟C++11提供的新式for循环，还有lambda表达式等进行配合使用。

6、基于范围的for循环(C++11)

6.1 范围for语法

通常我们都是如下这样遍历数组的：

void TestFor()
{
	int arr[] = { 1, 2, 3, 4, 5 };
	for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); ++i)
		cout << arr[i] << " ";
	cout << endl;
}

但对于一个有范围的集合而言，使用时去说明循环的范围是多余的，有时候还会容易犯错误。因此C++11中引入了基于范围的for循环。for循环后的括号由冒号“ ：”分为两部分：第一部分是范围内用于迭代的变量，第二部分则表示被迭代的范围。可以使用auto进行遍历：

void TestFor()
{
	int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8 };
	for (auto e : arr)
		cout << e << " ";
	cout << endl;
}

注：与普通循环类似，可以用continue来结束本次循环，也可以用break来跳出整个循环。

6.2 范围for使用条件

循环的范围必须是确定的，例如数组循环的范围就是第一个元素到最后一个元素的范围，如下就会出现问题：

void TestFor(int array[])
{
 for(auto& e : array)
 cout<< e <<endl;
}

7、指针空值nullptr(C++11)

在良好的C/C++编程习惯中，声明一个变量时最好给该变量一个合适的初始值，否则可能会出现不可预料的错误，比如未初始化的指针就是野指针了。指针未确定指向时一般会定义成指向空地址，即初始化指针为空指针。

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

在C语言中指针指向空地址使用的是NULL，但是NULL其实是一个宏，在传统的C头文件(stddef.h)中，可以看到如下代码：

#ifndef NULL
#ifdef __cplusplus
#define NULL 0
#else
#define NULL ((void *)0)
#endif
#endif

可以看到NULL可能被定义成字面常量0，也可能被定义成无类型指针(void*)的常量，无论是哪一种定义都有可能存在问题，比如：

我们本意是通过f(NULL)去调用f(int*)函数，但由于NULL这里使用的是字面常量0，从而导致调用的是f(int)函数，想要调用f(int*)函数还需要对NULL进行强转，都暴露出了NULL存在的一些问题。所以C++中引入了指针空值(nullptr)，指针空值就是表示一个无类型的指针(void*)，像上述程序若要调用f(int*)函数只需f(nullptr) 即可，无需强转。

注：

1. 在使用nullptr表示指针空值时，不需要包含头文件，因为nullptr是C++11作为新关键字引入的。

2. 在C++11中，sizeof(nullptr) 与 sizeof((void*)0)所占的字节数相同。

3. 为了提高代码的健壮性，在后续表示指针空值时建议最好使用nullptr。