《c++从0到99》 一 c++入门

Posted 2021-07-26 AURORA_CODE

c++入门

• 1. c++的认识
• 2. c++关键字
• 3. c++的命名空间
• • 01 命名空间的定义
  • 02 命名空间的使用
• 4. c++的输入输出
• 5. 缺省参数
• • 01 概念：
  • 02 缺省参数分类：
• 6. 函数重载
• • 01 概念
  • 02 实现
  • 03 函数命名规则
  • 04 extern "c"
• 7.引用
• • 01 引用的概念
  • 02 引用的特性
  • 03 常引用
  • 04 使用场景
  • 05 引用和指针的区别
• 8. 内联函数
• 9. auto关键字
• 10. 范围for循环
• • 01 语法
  • 02 使用条件
• 11.指针空值nullptr

1. c++的认识

C++ 是C语言的继承，它既可以进行C语言的过程化程序设计，又可以进行以抽象数据类型为特点的基于对象的程序设计，还可以进行以继承和多态为特点的面向对象的程序设计。C++擅长面向对象程序设计的同时，还可以进行基于过程的程序设计，因而C++就适应的问题规模而论，大小由之。
语言特点：

1. 支持数据封装和数据隐藏
   在C++中，类是支持数据封装的工具，对象则是数据封装的实现。C++通过建立用户定义类支持数据封装和数据隐藏。
   在面向对象的程序设计中，将数据和对该数据进行合法操作的函数封装在一起作为一个类的定义。对象被说明为具有一个给定类的变量。每个给定类的对象包含这个类所规定的若干私有成员、公有成员及保护成员。完好定义的类一旦建立，就可看成完全封装的实体，可以作为一个整体单元使用。类的实际内部工作隐藏起来，使用完好定义的类的用户不需要知道类是如何工作的，只要知道如何使用它即可。
2. 支持继承和重用
   在C++现有类的基础上可以声明新类型，这就是继承和重用的思想。通过继承和重用可以更有效地组织程序结构，明确类间关系，并且充分利用已有的类来完成更复杂、深入的开发。新定义的类为子类，成为派生类。它可以从父类那里继承所有非私有的属性和方法，作为自己的成员。
3. 支持多态性
   采用多态性为每个类指定表现行为。多态性形成由父类和它们的子类组成的一个树型结构。在这个树中的每个子类可以接收一个或多个具有相同名字的消息。当一个消息被这个树中一个类的一个对象接收时，这个对象动态地决定给予子类对象的消息的某种用法。多态性的这一特性允许使用高级抽象。
   继承性和多态性的组合，可以轻易地生成一系列虽然类似但独一无二的对象。由于继承性，这些对象共享许多相似的特征。由于多态性，一个对象可有独特的表现方式，而另一个对象有另一种表现方式。

2. c++关键字

在c++98版本c++共有63个关键词

asm	auto	bool	break	case
catch	char	class	const	const_cast
continue	default	delete	do	double
dynamic_cast	else	enum	explicit	export
extern	false	float	for	friend
goto	if	inline	int	long
mutable	namespace	new	operator	private
protected	public	register	reinterpret_cast	return
short	signed	sizeof	static	static_cast
struct	switch	template	this	throw
true	try	typedef	typeid	typename
union	unsigned	using	virtual	void
volatile	wchar_t	while

3. c++的命名空间

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

01 命名空间的定义

定义命名空间，需要使用到namespace关键字，后面跟命名空间的名字，然后接一对{}即可，{}中即为命名空间的成员。
一个命名空间就定义了一个新的作用域，命名空间中的所有内容都局限于该命名空间中

//1. 普通的命名空间
namespace A1 // A1为命名空间的名称
{
	// 命名空间中的内容，既可以定义变量，也可以定义函数
	int a;
	int Add(int left, int right)
	{
	return left + right;
	}
}
//2. 命名空间可以嵌套
namespace A2
{
	int a;
	int b;
	int Add(int left, int right)
	{
		return left + right;
	}
}
namespace A3
{
	int c;
	int d;
	int Sub(int left, int right)
	{
		return left - right;
	}
}
//3. 同一个工程中允许存在多个相同名称的命名空间,
//   编译器最后会合成同一个命名空间中。
namespace A1
{
	int Mul(int left, int right)
	{
	return left * right;
	}
}

02 命名空间的使用

命名空间的使用有三种方式：

• 加命名空间名称及作用域限定符

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

• 使用using将命名空间中成员引入

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

• 使用using namespace 命名空间引入

using namespce N;
int main()
{
	printf("%d\\n", N::a);
	printf("%d\\n", b);
	Add(10, 20);
	return 0;
}

4. c++的输入输出

#include <iostream>
using namespace std;
int main()
{
	int a,b;
	double c;
	cin>>a>>b>>c;
	cout<<"a="<<a<<endl;
	cout<<"b="<<b<<endl;
	cout<<"c="<<c<<endl;
	return 0;
}

1. 使用cout标准输出(控制台)和cin标准输入(键盘)时，必须包含< iostream >头文件以及std标准命名空间。
2. 使用C++输入输出更方便，不需增加数据格式控制，比如：整形–%d，字符–%c

5. 缺省参数

01 概念：

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

#include <iostream>
using namespace std;
void test(int a=10)
{
	cout << a << endl;	
}
int main()
{
	test();//不会报错，输出10，没有传参时使用的时参数的默认值
	test(5);//输出5，传入参数时，使用传入的值
	return 0;
}

02 缺省参数分类：

1. 全缺省参数

void test01(int a=1,int b=2,int c=3)// 全缺省
{
	cout << a << endl;
	cout << b << endl;
	cout << c << endl;
}

2. 半缺省参数

void test02(int a,int b,int c=3) //半缺省
{
	cout << a << endl;
	cout << b << endl;
	cout << c << endl;
}

• 半缺省参数必须从右往左依次给出，不能间隔着给
• 缺省参数不能在声明和定义中重复出现。
• 缺省值必须是常量或全局变量
• c语言的编译器不支持函数缺省

6. 函数重载

01 概念

函数重载:是函数的一种特殊情况，C++允许在同一作用域中声明几个功能类似的同名函数，这些同名函数的形参列表(参数个数或类型或顺序)必须不同，常用来处理实现功能类似数据类型不同的问题。

02 实现

#include <iostream>
using namespace std;
int add(int a, int b)
{
	return a + b;
}
double add(double a, double b)
{
	return a + b;
}
int main()
{
	cout<<add(1,2)<<endl;
	cout<<add(1.1111,2.2222)<<endl;
	return 0;
}

缺省参数缺省参数符合重载的定义，但如果调用的时候编译器无法识别函数重载调用哪个函数，就会发生意想不到的错误

03 函数命名规则

在C/C++中，一个程序要运行起来，需要经历以下几个阶段：预处理、编译、汇编、链接。

• 组成一个程序的每个源文件通过编译过程分别转换成目标代码。
• 每个目标文件由链接器捆绑在一起，形成一个单一而完整的可执行程序。
• 链接器同时也会引入标准C函数库中任何被该程序所用到的函数，而且它可以搜索程序员个人的程序库，将其需要的函数也链接到程序中。
  

1. 实际我们的项目通常是由多个头文件和多个源文件构成，而通过我们C语言阶段学习的编译链接，我们可以知道：编译后链接前，a.o的目标文件中没有Add的函数地址，因为Add是在b.cpp中定义的，所以Add的地址在b.o中。
2. 链接阶段就是专门处理这种问题，链接器看到a.o调用Add，但是没有Add的地址，就会到b.o的符号表中找Add的地址，然后链接到一起。

• 采用C语言编译器编译后结果
  在linux下，采用gcc编译完成后，函数名字的修饰没有发生改变
• 采用C++编译器编译后结果
  在linux下，采用g++编译完成后，函数名字的修饰发生改变，编译器将函数参数类型信息
  添加到修改后的名字中

• 通过这里就理解了C语言没办法支持重载，因为同名函数没办法区分。而C++是通过函数修饰规则来区分，只要参数不同，修饰出来的名字就不一样，就支持了重载。另外我们也理解了，为什么函数重载要求参数不同！而跟返回值没关系

04 extern “c”

有时候在C++工程中可能需要将某些函数按照C的风格来编译，在函数前加extern “C”，意思是告诉编译器，将该函数按照C语言规则来编译。比如：tcmalloc是google用C++实现的一个项目，他提供tcmallc()和tcfree两个接口来使用，但如果是C项目就没办法使用，那么他就使用extern “C”来解决

extern "C" int Add(int left, int right);
int main()
{
Add(1,2);
return 0;
}

链接时报错：error LNK2019: 无法解析的外部符号_Add，该符号在函数 _main 中被引用

7.引用

01 引用的概念

引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间

类型& 引用变量名(对象名) = 引用实体；

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

注意：引用类型必须和引用实体是同种类型的

02 引用的特性

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

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

03 常引用

void TestConstRef()
{
const int a = 10;
//int& ra = a; // 编译出错，a为常量
const int& ra = a;
// int& b = 10; // 编译出错，b为常量
const int& b = 10;
double d = 12.34;
//int& rd = d; // 编译出错，类型不同
const int& rd = d;
}

04 使用场景

1. 做参数

void Swap(int& left, int& right)
{
	int temp = left;
	left = right;
	right = temp;
}

2. 做返回值

#include <iostream>
using namespace std;
int& Add(int a, int b)
{
	int c = a + b;
	return c;
}
int main()
{
	int& ret = Add(1, 2);
	Add(3, 4);
	cout << "Add(1, 2) is :"<< ret <<endl;
	return 0;
}

如果函数返回时，出了函数作用域，如果返回对象还未还给系统，则可以使用引用返回，如果已经还给系统了，则必须使用传值返回

05 引用和指针的区别

在语法概念上引用就是一个别名，没有独立空间，和其引用实体共用同一块空间。

int main()
{
	int a = 10;
	int& ra = a;
	cout<<"&a = "<<&a<<endl;
	cout<<"&ra = "<<&ra<<endl;
	return 0;
}

在底层实现上实际是有空间的，因为引用是按照指针方式来实现的。

int main()
{
	int a = 10;
	int& ra = a;
	ra = 20;
	int* pa = &a;
	*pa = 20;
	return 0;
}

引用和指针的反汇编代码对比如下：

引用和指针的不同点：
1.引用访问一个变量是直接访问，而指针是间接访问。
2.引用是一个变量的别名，本身不单独分配自己的内存空间，而指针有自己的内存空间。
3.引用在开始的时候就绑定到了一个内存空间(开始必须赋初值),所以他只能是这个内存空间的名字,而不能改成其他的。 指针在任何时刻都可以改变自己的指向。

8. 内联函数

01 概念：

用inline修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方将代码展开（类似于宏定义），没有函数压栈的开销，内联函数提升程序运行的效率

如果在上述函数前增加inline关键字将其改成内联函数，在编译期间编译器会用函数体替换函数的调用。

02 特性：

1. inline是用空间换时间。所以代码很长或者有循环或递归的函数不适宜使用作为内联函数
2. inline对于编译器而言只是一个建议，编译器会自动优化，如果定义为inline的函数体内有循环或者递归等等，编译器优化时会忽略掉内联。
3. inline不建议声明和定义分离，分离会导致链接错误。

9. auto关键字

在C++11中，标准委员会赋予了auto全新的含义即：auto不再是一个存储类型指示符，而是作为一个新的类型指示符来指示编译器，auto声明的变量必须由编译器在编译时期推导而得

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

注意： 使用auto定义变量时必须对其进行初始化，因为在编译阶段编译器需要根据初始化表达式来推导auto的实际类型。因此auto并非是一种“类型”的声明，而是一个类型声明时的“占位符”，编译器在编译期会将auto替换为变量实际的类型。
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 Test()
{
auto a = 1, b = 2;
auto c = 3, d = 4.0; // 该行代码会编译失败，因为c和d的初始化表达式类型不同
}

auto不能推导的场景

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

// 此处代码编译失败，auto不能作为形参类型，因为编译器无法对a的实际类型进行推导
void Test(auto a)
{}

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

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

3. 为了避免与C++98中的auto发生混淆，C++11只保留了auto作为类型指示符的用法

10. 范围for循环

01 语法

对于一个有范围的集合而言，由程序员来说明循环的范围是多余的，有时候还会容易犯错误。因此C++11中引入了基于范围的for循环。
for循环后的括号由冒号“ ：”分为两部分：

• 第一部分是范围内用于迭代的变量。
• 第二部分则表示被迭代的范围。

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

02 使用条件

1. for循环迭代的范围必须确定
   对于数组而言，就是数组中第一个元素和最后一个元素的范围；对于类而言，应该提供begin和end的方法，begin和end就是for循环迭代的范围。
2. 迭代的对象要实现++和==的操作。

11.指针空值nullptr

在良好的C/C++编程习惯中，声明一个变量时最好给该变量一个合适的初始值，否则可能会出现不可预料的错误，比如未初始化的指针。如果一个指针没有合法的指向，我们基本都是按照如下方式对其进行初始化：

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

NULL实际是一个宏，在传统的C头文件(stddef.h)中

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

可以看到，NULL可能被定义为字面常量0，或者被定义为无类型指针(void)的常量
在C++98中，字面常量0既可以是一个整形数字，也可以是无类型的指针(void*)常量，但是编译器默认情况下将其看成是一个整形常量，如果要将其按照指针方式来使用，必须对其进行强转(void *)0。
注意：

1. 在使用nullptr表示指针空值时，不需要包含头文件，因为nullptr是C++11作为新关键字引入的。
2. 在C++11中，sizeof(nullptr) 与 sizeof((void*)0)所占的字节数相同。
3. 为了提高代码的健壮性，表示指针空值时建议最好使用nullptr。

以上就是这篇文章的所有内容啦，感谢老铁有耐心看完。有啥错误请多多指正哈！码字不易，希望大佬们点个赞