C++的一些基础语法

目录

一、命名空间

二、缺省函数

三、函数重载

四、引用

1.  引用的常见使用场景：
2. 引用和指针的区别：

五、inline定义的内联函数

1. 内联函数的使用：
2. 使用注意事项：

六、auto关键字

七、范围for

---

一、命名空间

命名空间的定义：命名空间（Namespace）是一种将变量、函数和其他代码组织起来以便在不同作用域中使用的机制。用于避免命名冲突，使得不同模块或库可以在同一程序中使用，而不会相互干扰。

命名空间的用法：

//创建一个名字为test1的命名空间
namespace test1
{
	int rand = 0;
	//命名空间可以嵌套
	namespace test2
	{
		int a = 0;
		void Print()
		{
			printf("hello world\n");
		}

		struct Node
		{
			int a;
			struct Node* next;
		};
	}
}

命名空间中的变量名不能直接使用，一般有以下几种使用方法：

• 直接将命名空间展开，将作用域中所有的数据都暴露出来。不推荐，违背了命名空间创建的初衷
• 使用展开命名空间中指定的部分
• 使用域作用限定符，在命名空间中查找需要的变量名

//现在全局域找，没找到；在展开的std域中去找
using namespace std;//std是C++标准库中的命名空间
//using可以展开命名空间

using std::cin;

int main()
{ 
	//::域作用限定符，左边域名，右边变量名。左边为空默认在全局域搜索
	printf("%d\n", test1::test2::a);

	return 0;
}

二、缺省函数

缺省函数的定义：缺省函数是指在函数的参数列表中，某个或多个参数有默认值，当调用函数时，如果实参未给出对应的参数，则使用该参数的默认值。

缺省函数的使用：

void Func(int a = 0)//对形参赋值，当实参为空时，默认传递为形参值
{
	cout << a << endl;
}

函数的声明和定义分离时：在声明中定义了缺省函数，在函数定义中不可重复定义。如果声明中未定义缺省参数，即使定义中定义了缺省参数，也不可以缺省使用。

void TestFunc2(int a, int b, int c = 40);
int main()
{
	//TestFunc2();//不支持传递空参数
	//TestFunc2(1);//参数数量必须>=未缺省形参数量
	TestFunc2(1, 2);
	TestFunc2(1, 2, 3);

	return 0;
}
//半缺省，缺省部分参数
void TestFunc2(int a, int b, int c)
{
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	cout << "c = " << c << endl << endl;
}

三、函数重载

函数重载的定义：函数重载（Function Overloading）是指在同一个作用域内，可根据参数的个数、类型、顺序的不同，定义多个同名函数，编译器可以根据编译过后修正的函数名链接到相对应的函数。

函数重载的使用，要满足几点要求：同一作用域 && (参数个数不同 || 参数类型不同 || 参数位置不同)（后三点就是为了区分这两个函数）

void Func(int i)
{
	cout << "void Func(int i): " << i << endl;
}
void Func(int i, char c)//个数不同
{
	cout << "void Func(int i, char c): " << i << ',' << c << endl;
}
void Func(double d)//参数类型不同
{
	cout << "void Func(double d): " << d << endl;
}
void Func(char c, int i)//位置不同
{
	cout << "void Func(char c, int i): " << c << ',' << i << endl;
}
int main()
{

	Func(4);
	Func(1.2);
	Func(4, 'a');
	Func('a', 4);

	return 0;
}

四、引用

引用的功能:给变量名起一个别名。引用不像指针，需要使用“*”运算符才可对其中的数据进行操作。它允许直接通过新的变量名对原始变量进行操作，但是必须对引用进行初始化操作。

int main()
{
	int a = 10;
	int& b = a;

	int x = 20;
	//引用引用了一个实体，就不能在引用其他实体
	b = x;

	cout << a << " " << b << endl;
	cout << &a << " " << &b << endl;

	return 0;
}

 引用的常见使用场景：

• 作为函数参数：作为函数参数接收的是实参的引用，可以直接使用

void Swap(int& x, int& y)
{
	int tmp = x;
	x = y;
	y = tmp;
}
int main()
{
	int a = 10, b = 20;
	Swap(a, b);

	return 0;
}

• 传引用返回：根据函数栈帧的特性，函数调用完毕之，栈帧销毁时，变量也会被销毁的不能通过传引用返回；变量不被销毁的可以使用传引用返回

int& Count()
{
	//int n = 0;
	static int n = 0;//可以使用传引用返回
	n++;

	return n;//将n的值作为函数的返回值，但是函数的返回值类型是引用
}
int main()
{
	//要注意：函数的调用完成之后，之前函数所申请的空间会被销毁，虽然我们用引用将之前n所在的空间保存了下来，实际上是对内存空间的非法访问，这块空间并不是我们能实际掌控的
	//int ret = Count();

	int& ret = Count();
	//将返回的空间在进行引用，传给printf函数
	printf("%d\n", ret);//第一次能成功打印出正常值是因为运气好，在调用printf函数的时候建立的栈帧并没有对ret所在空间进行修改。
	//printf函数结束之后，销毁栈帧空间的时候，对ret所在空间修改了，第二次打印就出现了错误。
	printf("%d\n", ret);
	//因此我们在传引用返回的时候要注意：栈帧会销毁时，同时变量也会被销毁的不能通过传引用返回；变量不被销毁的可以使用传引用返回

	return 0;
}

引用和指针的区别：

语法角度：指针开辟了空间，引用没开辟空间
底层实现角度：引用是用指针实现的 

五、inline定义的内联函数

内联函数的定义：用inline修饰的函数，在满足条件的情况下，编译时直接在调用内联函数的地方展开，不进行压栈的开销

内联函数的使用：

inline int Add(int x, int y)
{
	return x + y;
}
int main()
{
    //内联函数本质上是代替宏函数，克服了宏不检查类型，无法调试，可读性差的弊端
	cout << Add(1, 2) << endl;

	return 0;
}

使用注意事项：

1、inline对于编译器只是建议，如果遇到递归或者编译之后执行代码太长的函数（大概10行左右，编译器决定），编译器可能不会支持inline；

2、inline不建议声明和定义分离，在展开的情况下声明所指向的地址会消失

六、auto关键字

auto功能：自动推导类型

auto用法：

int test()
{
	return 1;
}
int main()
{
	int a = 10;
	auto b = a;
	auto c = 'a';
	auto d = test();
	cout << "b的类型为：" << typeid(b).name() << endl;
	cout << "c的类型为：" << typeid(c).name() << endl;
	cout << "d的类型为：" << typeid(d).name() << endl;

	return 0;
}

七、范围for

范围for：范围for是一种语法，它允许程序员在不需要具体迭代器的情况下，遍历各种数据结构（例如数组、向量、列表等）中的元素，作为一个新的语法特性。for循环后的括号由冒号“ ：”分为两部分：第一部分是范围内用于迭代的变量，第二部分则表示被迭代的范围。

int main()
{
	int a[] = { 1,2,3,4,5,6,7,8 };
	//范围for：自动依次拾取a的数据，赋值给e。自动迭代自动判断结束
	for (auto e : a)
	{
		cout << e << ' ';
	}
	cout << endl;
	return 0;
}