【C++】命名空间&缺省参数&函数重载&引用&内联函数

//C++兼容C的语法

//C语言版本hello world
#include<stdio.h>
int main()
{
	printf("hello world\n");
	return 0;
}

//C++版本hello world
#include<iostream>
using namespace std;
int main()
{
	cout << "hello world" << endl;
	return 0;
}

#include<stdio.h>


int main()
{
	
	int scanf = 10;//对
	int strlen = 20;//对
	//C语言中标识符命名的两个点：1.不能以数字，下划线开头 2.不能和关键字名字一样（但可以是函数名）


	printf("%d", scanf);//对
	printf("%d\n", strlen);//对


	scanf("%d", &scanf);//错
	//本意是第一个scanf用stdio.h里的库函数，第二个scanf用int类型的变量
	//但是C语言的局部优先原则，这里的两个scanf都是int类型的变量，所以出错

	//小结：如果我就是想要达成我的本意的这个目的，C语言明显做不到（有命名冲突的问题），所以C++就使用namespace命名空间域来完善C
}

#include<iostream>

//定义的是一个命名空间域:（变量和函数构成）
namespace song
{
	//变量
	int scanf = 1;
	int strlen = 2;

	//函数
	int add(int a, int b)
	{
		return a + b;
	}
}

int main()
{
	//默认访问的是先局部后全局(局部没有则采用局部的）
	printf("%x\n", scanf);
	printf("%x\n", strlen);

	//指定访问song命名空间域
	printf("%x\n", song::scanf);
	printf("%x\n", song::strlen);

	printf("%d\n", song::add(10,20));
}

#include<iostream>
//全局域
int a = 10;

//命名空间域可以嵌套
namespace song
{
	int a = 20;

	namespace huang
	{
		int a = 30;
	}

	namespace chen
	{
		int a = 40;
	}
}

//类域
class stu
{
public:
	int a = 50;
};


int main()
{

	printf("默认先局部后全局（局部没有，全局有）：a=%d\n", a);


	printf("指定song命名空间域:a=%d\n", song::a);


	printf("指定song命名空间域里的haung命名空间域:%d\n", song::huang::a);


	printf("指定song命名空间域里的chen命名空间域:%d\n", song::chen::a);

	stu s;
	printf("类域:%d\n", s.a);

	return 0;
}

#include<iostream>

int main()
{
	//要使用标准库里的东西,有三种方式:


	//方式1:每一个都指定命名空间
	//麻烦但是最标准
	std::cout << "hello world1" << std::endl;

	//方式2:整个东西都在全局展开,一夜回到解放前
	//方便,但是当我们自己定义的和标准库里的东西名字相同,发生命名冲突的时候就没办法解决了
	using namespace std;
	cout << "hello world2" << endl;

	//方式3:折中办法,对于标准库中的部分常用进行展开
	using std::cout;
	using std::endl;
	cout << "hello world3" << endl;


	return 0;
}

//ostream 类型全局对象 cout
//istream 类型全局变量 cin
//endl 全局的换行符号

#include<iostream>
using namespace std;
int main()
{
	int a = 0;
	cin >> a;
	//自动识别类型:原理就是函数重载和运算符重载
	cout << a<< endl<< &a << endl;

	return 0;
}

#include<iostream>
using namespace std;

//缺省参数的分类

//1:全缺省
void test1(int a=10, int b=20, int c=30)
{
	cout << a << endl;
	cout << b << endl;
	cout << c << endl << endl;
}

//2:半缺省
//部分缺省-必须从右往左连续缺省
void test2(int a , int b , int c =10)
{
	cout << a << endl;
	cout << b << endl;
	cout << c << endl;
}
int main()
{

	test1(1, 2, 3);

	test2(1, 2);//实参个数>=没缺省的参数个数

	return 0;
}

#include<iostream>

typedef struct Stack
{
	int* a;
	int size;
	int capacity;
}Stack;

//老版本:
//void InitStack(Stack* ps)
//{
//	ps->a = (int*)malloc(sizeof(int) * 4);
//	ps->size = 0;
//	ps->capacity = 4;
//}

//新版本:
void InitStack(Stack* ps, int capacity=4)
{
	ps->a = (int*)malloc(sizeof(int) * capacity);
	ps->size = 0;
	ps->capacity = capacity;
}

int main()
 {
	//假设我知道栈内至少需要存100个数据
	//如果现在将上面的capacity写成100,下面我ST2就没办法使用了
	//如果现在将上面的capacity写成10,在这里就要扩容,扩容是有时间成本的
	Stack ST1;
	//老版本:InitStack(&ST1);
	//新版本:
	InitStack(&ST1, 100);//传了,使用传的100

	//假设我知道栈内至少需要存10个数据
	Stack ST2;
	//老版本:InitStack(&ST2);
	InitStack(&ST2, 10);//传了,使用传的10

	//假设我不知道栈内至少需要存多少个数据
	Stack ST3;
	InitStack(&ST3);//不传,使用备用的4
	return 0;
}

void InitStack(Stack* ps, int capacity = 4);//声明缺省

int main()
 {
    //业务需求;
	return 0;
}

//新版本:
void InitStack(Stack* ps, int capacity)//定义不缺省
{
	ps->a = (int*)malloc(sizeof(int) * capacity);
	ps->size = 0;
	ps->capacity = capacity;
}

#include<iostream>
using namespace std;

int Add(int a, int b)
{
	return a + b;
}

char Add(char a, char b)
{
	return a + b;
}

double Add(double a, double b)
{
	return a + b;
}

float Add(float a, float b)
{
	return a + b;
}

int Add(int a, int b, int c)
{
	return a + b + c;
}

int main()
{
	cout << Add(1, 1) << endl;

	cout << Add('1', '1') << endl;//函数参数的类型构成重载
	cout << Add(1.1, 1.1)<< endl;//函数参数的类型构成重载//!!!备注:如果没强转或者备注,1.1默认就是double类型
	cout << Add((float)1.1, (float)1.1)<< endl;//函数参数的类型构成重载//强转
	//cout << Add(1.1f, 1.1f)<< endl;//函数参数的类型构成重载//备注



	cout << Add(1, 1, 1) << endl;//函数参数的个数构成重载

	return 0;
}

#include<iostream>
int main()
{
	int a = 10;
	int& b = a;//b是a的别名，b是a的引用
	printf("%d\n", b);

	b = 100;
	printf("%d\n", a);
}

#include<iostream>

using namespace std;

void Swap(int* m, int* n)
{
	int temp = *m;
	*m = *n;
	*n = temp;
}

void Swap(int& m, int& n)
{
	int temp = m;
	m = n;
	n = temp;
}

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

	//传地址交换
	Swap(&a, &b);
	printf("a=%d\tb=%d\n", a, b);

	//传引用交换
	Swap(a, b);
	printf("a=%d\tb=%d\n", a, b);


	return 0;
}

int main()
{
	
	int a = 10;

	//一个变量可以有多个别名b,c,d
	int& b = a;
	int& c = a;
	int& d = a;

	//引用必须初始化
	int& e = a;

	//不是让e变成r的别名,而是把r赋值给e
	int r = 20;
	e = r;
	printf("%d\n", e);//20

	return 0;
}

int main()
{
    //const权限
    const int a = 10;//这里的a是可读不可写
	int& ra = a;//错,权限的放大不允许
	//错在把可读不可写的变量a给一个可读可写的引用
	const int& ra = a;//对



	int b = 10;//-可读可写
	const int& rb = b;//对,权限的缩小允许-可读不可写


	return 0;
}

	//隐式转换（权限的应用）
	int c = 10;
	double d = 1.1;
	d = c;//对，c语言隐式类型转换，但还是一样是有临时变量(double)类型

	//double& rc = c;//错,错因是因为是const double 类型的临时变量给了double类型的变量
	const double& rc = c;//对

int& Add(int a, int b)
{
	int c = a + b;
	return c;
}

int main()
{
	const int& ret = Add(1, 2);
	Add(5, 7);
	cout << ret << endl;//12
	return 0;
}

int main()
{
	int a = 10;
	
	//语法上，这里是给a起了一个别名，而是新定义了一个符号，并没有额外开空间
	int& ra = a;
	ra = 20;

	//语法上，这里是定义了内存是4个字节的变量存放a的地址
	int* pa = &a;
	*pa = 20;

	return 0;
}

//C语言为了避免小函数开辟函数栈帧的开销--->提供了宏，预处理阶段展开
#define Add(x,y)  ((x)+(y))
int main()
{
	int x = 1, y = 2;
	int ret = Add(1, 2);
	printf("%d\n", ret);

	return 0;
}

inline int Add(int a, int b)
{
	return a + b;
}

int main()
{
	int x = 1, y = 2;
	int ret = Add(1, 2);
	printf("%d\n", ret);

	return 0;
}