【c++】c++入门

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

---

---

一、命名空间

namespace即“命名空间”，也称“名称空间” 。是许多编程语言使用的一种代码组织的形式，通过命名空间来分类，区别不同的代码功能，避免不同的代码片段（通常由不同的人协同工作或调用已有的代码片段）同时使用时由于不同代码间变量名相同而造成冲突。

1.1命名空间定义

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

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

1.命名空间中可以定义变量/函数/类型
2. 命名空间可以嵌套
3. 同一个工程中允许存在多个相同名称的命名空间,编译器最后会合成同一个命名空间中。

1.2 命名空间使用

我们以上面的命名空间为例，有三种使用命名空间的方法
1. 加命名空间名称及作用域限定符

int main()
{
	printf("%d\n", Room::ra);
	printf("%d\n",Room:: Add(3, 4));
	return 0;
}

2.使用using namespace 命名空间名称 引入
是将整个命名空间进行展开，展开后在全局的任何地方可以直接调用

using namespace Room;
int main()
{
	printf("%d\n", ra);
	printf("%d\n", Add(3, 4));
	return 0;
}

3.使用using将命名空间中某个成员引入
与方法二不同的是，方法三虽然也是展开命名空间，不过只会展开命名空间的部分内容。

using Room::Add;
int main()
{
	printf("%d\n", Room::ra);
	printf("%d\n",Add(3, 4));
	return 0;
}

二、c++的输入&输出

#include<iostream>
// std是C++标准库的命名空间名，C++将标准库的定义实现都放到这个命名空间中
using namespace std;
int main()
{
	int a, b;
	cin >> a >> b;//输入
	cout << "a=" << a << endl;//输出  注意：endl 相当于 \n 
	cout << "b=" << b << endl;
	return 0;
}

说明：

1. 使用cout标准输出对象(控制台)和cin标准输入对象(键盘)时，必须包含< iostream >头文件以及按命名空间使用方法使用std。
2. cout和cin是全局的流对象，endl是特殊的C++符号，表示换行输出，他们都包含在包含< iostream >头文件中。
3. <<是流插入运算符，>>是流提取运算符。
4. 使用C++输入输出更方便，不需要像printf/scanf输入输出时那样，需要手动控制格式。C++的输入输出可以自动识别变量类型。

三.缺省参数

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

缺省参数分类
1.全缺省参数

 //全缺省参数
//全缺省参数在传参时只能从左往右给
//TestFunc(int a,int b = 2,int c)这是不允许的
void TestFunc(int a = 10, int b = 20, int c = 30)
{
	cout << "a=" << a << endl;
	cout << "b=" << b << endl;
	cout << "c=" << c << endl<<endl;
}

2.半缺省参数

//半缺省参数:缺省部分参数
//缺省只能从右往左缺省，且连续缺省
//不能TestFun(int a = 2,int b,int c =30)
void TestFun(int a, int b = 20, int c = 30)
{
	cout << "a=" << a << endl;
	cout << "b=" << b << endl;
	cout << "c=" << c << endl << endl;
}

以TestFunc(int a = 10, int b = 20, int c = 30)函数为例

int main()
{
    TestFunc(1, 2, 3);//打印a = 1,b = 2 ,c=3
	TestFunc(1);//打印a = 1,b = 20 ,c = 30
	TestFunc(1,2);//打印a = 1,b = 2 ,c = 30
	TestFunc();//打印a = 10 ,b = 20 ,c = 30 
	return 0;
}

注意
1. 半缺省参数必须从右往左依次来给出，不能间隔着给
2. 缺省参数不能在函数声明和定义中同时出现，分离定义时：声明给缺省参数

四.函数重载

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

//类型不同
int Add(int left, int right)
{
	return left + right;
}
double Add(double left, double right)
{
	return left + right;
}

//顺序不同
void func(int i, char ch)
{
	cout << "void func(char ch,int i)" << endl;
}
void func(char ch,int i)
{
	cout << "void func(int i,cahr ch)" << endl;
}
int main()
{
	cout << Add(1, 2) << endl;
	cout << Add(1.2, 3.1) << endl;

	func('a', 5);
	func(10, 'b');
	return 0;
}

五.引用

5.1引用概念

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

int main()
{
	int a = 0;
	int& b = a;//引用
	//注意：引用类型必须和引用实体是同种类型的
	cout << &a << endl;
	cout << &b << endl;//取地址
	return 0;
}

5.2引用特性

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

int main()
{
	int a = 1;
	//int& b;//不能这样写，引用定义必须初始化
	int& b = a;
	int& c = a;//一个变量可以多个引用

	int x = 5;
	b = x;
	//引用一旦引用一个实体，再不能引用其他实体
	//b = x;//这是将x的值赋值给b，这样写了后a的值也会变成5
	return 0;
}

5.3常引用

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;
}

5.4引用的用途

1.做参数 ——a.输出性参数 b.大对象传参，提高效率

int& Count()
{
	int n = 0;
	n++;
	// ...
	return n;//返回n的别名
}
int main()
{
	int  ret = Count();
	int& rat = Count();
	//ret的结果是未定义的，如果栈帧结束时，系统会清理栈帧生成随机值
	//那么这里的ret就是随机值
	cout << ret << endl;
	printf("%d\n", rat);
	printf("%d\n", rat);
	return 0;
}

2.做返回值–a,输出型返回对象，调用者可以修改返回对象 b.减少拷贝

有误使用：

int& Count()
{
	int n = 0;
	n++;
	// ...
	return n;//返回n的别名
}
int main()
{
	int  ret = Count();
	int& rat = Count();
	//ret的结果是未定义的，如果栈帧结束时，系统会清理栈帧生成随机值
	//那么这里的ret就是随机值
	cout << ret << endl;
	printf("%d\n", rat);
	printf("%d\n", rat);
	return 0;
}
结论：上面的程序使用引用返回本质是不对的，结果是没有保障的

正确使用：

int& Count()
{
 //静态变量不会随着函数结束而销毁，就可以用传引用返回
	static int n = 0;
	n++;
	// ...
	return n;//返回n的别名
}
int main()
{
	int  ret = Count();
	cout << ret << endl;
	
	return 0;
}

六. 内联函数

以inline修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开，没有函数调用建立栈帧的开销，内联函数提升程序运行的效率。
内联函数几乎解决了宏函数的所以缺点，也兼具着宏函数的优点如果在上述函数前增加inline关键字将其改成内联函数，在编译期间编译器会用函数体替换函数的调用。

内联函数优缺点：
优点：
1.它通过避免函数调用所带来的开销来提高你程序的运行速度。
2.当函数调用发生时，它节省了变量弹栈、压栈的开销。
3.它避免了一个函数执行完返回原现场的开销。
4.通过将函数声明为内联，你可以把函数定义放在头文件内。

缺点：
1.因为代码的扩展，内联函数增大了可执行程序的体积。
2.C++内联函数的展开是中编译阶段，这就意味着如果你的内联函数发生了改动，那么就需要重新编译代码。
3.当你把内联函数放在头文件中时，它将会使你的头文件信息变多，不过头文件的使用者不用在意这些。
4.有时候内联函数并不受到青睐，比如在嵌入式系统中，嵌入式系统的存储约束可能不允许体积很大的可执行程序。

七.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;//auto就推导为int
auto b = 2;
auto c = 3;
auto d = 4.0;//auto 被推导为int，但是这里d赋值不为int，会报错
 // 该行代码会编译失败，因为c和d的初始化表达式类型不同
}

1. auto不能作为函数的参数
2.auto 不能作用于类的非静态成员变量（也就是没有 static 关键字修饰的成员变量）中。
3. auto 关键字不能定义数组，比如下面的例子就是错误的：

4. auto 不能作用于模板参数

八.基于范围的for循环

// 范围for
void TestFor()
{
	int a[] = { 1, 2, 3, 4, 5 };
	int b[] = { 3, 4, 5, 6, 7 };
	cout << "数组a: ";
	// 自动依次取a与b的数据，赋值给e
    // 自动迭代，自动判断结束
	for (auto e : a)
	{
		cout << e << "  ";
	}
	cout << endl;

	for (auto& e : b)
	{
		e--;
	}
	cout << "b数组：";
	for (auto e : b)
	{
		cout << e << "  ";
	}
}
int main()
{
	TestFor();
	return 0;
}