c++入门(1)

       c++是一门广泛使用的计算机编程语言，刚开始学习 C++时， 我们需要认真学习 C++的基本语法规则，包括变量声明、数据类型、控制结构（如条件语句、循环语句）等。确保对每一个语法点都理解透彻，避免在后续编程中出现低级错误。注意 C++与其他编程语言在语法上的差异，比如 C++中的指针操作、引用等概念是一些其他语言中没有的，需要特别留意。

1.c++简单程序

       C++兼容C语言绝大多数的语法，C++中需要把定义文件代码后缀改为.cpp，vs编译器看到是.cpp就会调⽤C++编译器编译，linux下要⽤g++编译，不再是gcc。

#include<stdio.h>
int main()
{
printf("hello henu\n");
return 0;
}

当然C++有⼀套自己的输⼊输出，严格说C++版本的应该是这样写的。 

#include <iostream>
using namespace std;

int main()
{
	cout << "hellow henu" << endl;
	return 0;

}

2.命名空间

2.1namespace命名空间的价值

命名空间（namespace）可以避免命名冲突。在大型项目中，可能会有多个开发人员同时工作，或者使用来自不同库的代码。如果没有命名空间，不同模块中相同名称的标识符很容易发生冲突。例如：两个不同的函数库可能都定义了一个名为“func”的函数。使用命名空间后，可以分别通过不同的命名空间来访问这些函数，避免了冲突。
 

#include <stdio.h>
#include <stdlib.h>
int rand = 10;
int main()
{
     // 编译报错：error C2365: “rand”: 重定义；以前的定义是“函数”
     printf("%d\n", rand);
     return 0;
}

2.2namespace命名空间的定义

（1）定义命名空间，需要使用到namespace关键字，后面跟命名空间的名字，然后接⼀对{}即可，{}中即为命名空间的成员。命名空间中可以定义变量/函数/类型等。

（2）namespace本质是定义出⼀个域，这个域跟全局域各自独立，不同的域可以定义同名变量

（3）C++中域有函数局部域，全局域，命名空间域，类域；域影响的是编译时语法查找⼀个变量/函数/ 类型出处(声明或定义)的逻辑，所有有了域隔离，名字冲突就解决了。局部域和全局域除了会影响编译查找逻辑，还会影响变量的生命周期，命名空间域和类域不影响变量生命周期。

（4）namespace只能定义在全局，当然它还可以嵌套定义。

（5）项目工程中多文件中定义的同名namespace会认为是⼀个namespace，不会冲突。

（6）C++标准库都放在⼀个叫std(standard)的命名空间中。

普通的命名空间定义：

#include <iostream>
using namespace std;
namespace henu
{
	//命名空间中可以定义变量、函数、类型
	int rand = 10;

	int add(int x, int y)
	{
		return x + y;
	}

	struct Node
	{
		struct Node* next;
		int val;
	};
}
int main()
{
	//这里访问的是全局变量中的rand函数指针
	printf("%p\n", rand);
	//这里指定henu命名空间中的rand
    //域作用限定符“::“
	printf("%d\n", henu::rand);
	return 0;
}

嵌套定义：

#include <iostream>
using namespace std;
namespace henu
{
	namespace w1
	{
		int rand = 10;
		
		int add(int x, int y)
		{
			return x + y;
		}
	}

	namespace w2
	{
		int rand = 20;

		int minus(int x, int y)
		{
			return x - y;
		}
	}
}
int main()
{
	printf("%d\n", henu::w1::rand);//10
	printf("%d\n", henu::w2::rand);//20

	printf("%d\n", henu::w1::add(5, 3));//8
	printf("%d\n", henu::w2::minus(5, 3));//2

	return 0;
}

多文件中可以定义同名namespace，它们会默认合并到一起，

2.3namespace命名空间的使用

编译查找⼀个变量的声明/定义时，默认只会在局部或者全局查找，不会到命名空间里面去查找。所以下面程序会编译报错。所以我们要使用命名空间中定义的变量/函数，有三种方式：

（1） 指定命名空间访问，项目中推荐这种方式。

（2） using将命名空间中某个成员展开，项目中经常访问的不存在冲突的成员推荐这种方式。

（3） 展开命名空间中全部成员，项目不推荐，冲突风险很大，日常小练习程序为了方便推荐使用。

错误使用： 

#include <iostream>
using namespace std;
namespace henu
{
	int x = 10;
	int y = 20;
}
int main()
{
	//报错,未定义标识符x
	printf("%d", x);
	return 0;
}

指定命名空间访问：

#include <iostream>
using namespace std;
int main()
{
	printf("%d", henu::x);
	return 0;
}

//using 将整个命名空间展开
using namespace henu;
int main()
{
	printf("%d ", x);
	printf("%d ", y);
	return 0;
}

using 将命名空间中的某个成员展开:

#include <iostream>
using namespace std;
namespace henu
{
	int x = 10;
	int y = 20;
}
using henu::x;
int main()
{
	printf("%d ", x);
	return 0;
}

3.c++输入和输出

（1）<iostream> 是 Input Output Stream 的缩写，是标准的输入、输出流库，定义了标准的输入、输

出对象。

（2）std::cin 是 istream 类的对象，它主要面向窄字符（narrow characters (of type char)）的标准输入流。

（3）std::cout 是 ostream 类的对象，它主要面向窄字符的标准输出流。

（4）std::endl 是⼀个函数，流插入输出时，相当于插入⼀个换行字符加刷新缓冲区。

（5） <<是流插入运算符，>>是流提取运算符。（C语言还用这两个运算符做位运算左移/右移）

（6）使用 C++输入输出更方便，不需要像printf/scanf输⼊输出时那样，需要手动指定格式，C++的输入输出可以自动识别变量类型(本质是通过函数重载实现的，这个以后会讲到)，其实最重 要的是 C++的流能更好的支持自定义类型对象的输入输出。

（7）cout/cin/endl等都属于C++标准库，C++标准库都放在⼀个叫std(standard)的命名空间中，所以要通过命名空间的使用方式去用他们。

（8）⼀般日常练习中我们可以using namespace std，实际项目开发中不建议using namespace std。

（9） 这⾥我们没有包含<stdio.h>，也可以使用printf和scanf，在包含<iostream>间接包含了。vs系列 编译器是这样的，其他编译器可能会报错。

#include <iostream>
using namespace std;
int main()
{
	cout << "hellow henu\n";
	cout << "hellow henu" << endl;

	int a = 10;
	double b = 0.1;
	char c = 'x';
	cout << a << " " << b << " " << c << endl;
	//10 0.1 x
	std::cout << a << " " << b << " " << c << std::endl;
	//10 0.1 x

	scanf("%d %lf", &a, &b);
	printf("%d %lf\n", a, b);

	//可以自动识别变量类型
	cin >> a;//输入10
	cin >> b >> c;//输入0.1,'x'
	
	cout << a << endl;
	cout << b << " " << c << endl;
    //10
    //0.1 x

	return 0;
}

4.缺省参数

（1）缺省参数是声明或定义函数时为函数的参数指定⼀个缺省值。在调用该函数时，如果没有指定实参则采用该形参的缺省值，否则使用指定的实参，缺省参数分为全缺省和半缺省参数。（有些地方也把缺省参数叫作默认参数）

（2）全缺省就是全部形参给缺省值，半缺省就是部分形参给缺省值。C++规定半缺省参数必须从右往左依次连续缺省，不能间隔跳跃给缺省值。

（3）带缺省参数的函数调用，C++规定必须从左到右依次给实参，不能跳跃给实参。

（4） 函数声明和定义分离时，缺省参数不能在函数声明和定义中同时出现，规定必须函数声明给缺省值。

代码1：

void fun(int a = 0)
{
	cout << a << endl;
}

int main()
{
	//没有传参，使用参数默认值
	fun();
	//传参，使用指定参数
	fun(10);
	return 0;
}

代码2：

//全缺省
void fun1(int a = 10, int b = 20, int c = 30)
{
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	cout << "c = " << c << endl;
}
//C++规定半缺省参数必须从右往左依次连续缺省，不能间隔跳跃给缺省值
//半缺省
void fun2(int a, int b = 10, int c = 20)
{
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	cout << "c = " << c << endl;
}
//错误的
//void fun2(int a = 10, int b = 10, int c)
//{
//	cout << "a = " << a << endl;
//	cout << "b = " << b << endl;
//	cout << "c = " << c << endl;
//}

int main()
{
	fun1();//10 20 30 
	fun1(1);//1 20 30
	fun1(1, 2);//1 2 30
	fun1(1, 2, 3);//1 2 3
	//错误的 fun(1, , 3);

	//错误的 fun2();
	fun2(100);
	fun2(100,200);
	fun2(100,200,300);
	return 0;
}

代码3：函数声明和定义分离时，缺省参数不能在函数声明和定义中同时出现，规定必须函数声明给缺省值。

typedef int STDataType;
typedef struct Stack
{
	STDataType* a;
	int top;
	int capacity;
}ST;
void STInit(ST* ps, int n = 4);

// 缺省参数不能声明和定义同时给
void STInit(ST* ps, int n)
{
	assert(ps && n > 0);
	ps->a = (STDataType*)malloc(n * sizeof(STDataType));
	ps->top = 0;
	ps->capacity = n;
}
int main()
{
	ST s1;
	STInit(&s1);
	// 确定知道要插⼊1000个数据，初始化时⼀把开好，避免扩容
	ST s2;
	STInit(&s2, 1000);
	return 0;
}

5.函数重载

C++支持在同⼀作用域中出现同名函数，但是要求这些同名函数的形参不同，可以是参数个数不同或者类型不同。 这样C++函数的使用就更加灵活。C语言是不支持同⼀作用域中出现同 名函数的。

//参数类型不同
int Add(int a, int b)
{
	cout << a << " " << b << endl;
	return a + b;
}
double Add(double a, double b)
{
	cout << a << " " << b << endl;
	return a + b;
}

//参数个数不同
void fun()
{
	cout << "fun()" << endl;
}
void fun(int a)
{
	cout << "fun(int a)" << endl;
}
void fun(int a, int b)
{
	cout << "fun(int a, int b)" << endl;
}

//参数类型顺序不同
void fun(int a, char b)
{
	cout << "fun(int a, char b)" << endl;
}
void fun(char a, int b)
{
	cout << "fun(char a, int b)" << endl;
}
void Swap(int* a, int* b)
{
	//...
}
void Swap(double* a, double* b)
{
	//...
}

int main()
{
	Add(10, 20);
	Add(1.1, 2.2);

	fun();
	fun(10);
	fun(10, 20);

	fun(10, 'a');
	fun('a', 10);

	int a = 1, b = 2;
	double c = 1.1, d = 2.2;
	Swap(&a, &b);
	Swap(&c, &d);
	return 0;
}

 两个有误示例：

//返回值不同不能作为重载条件，因为调⽤时也⽆法区分
void fxx()
{
}

int fxx()
{
 return 0;
}
 下⾯两个函数构成重载
 f()但是调⽤时，会报错，存在歧义，编译器不知道调⽤谁
void f1()
{
	cout << "f()" << endl;
}
void f1(int a = 10)
{
	cout << "f(int a)" << endl;
}
int main()
{
	f1();
	return 0;
}