初识C++

第一个C++程序

c++相较于c语言来说是一个提升解决了C语言方面存在的不足，下面我们就来比较一下c++和c的不同
这个是c++的

# include <iostream>
using namespace std;
nt main()
{
	cout << "hello,word!" << endl;
	return 0;
}

这个是c语言的

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

我们发现C++相较与C语言，直观的看到就感觉C++的写法相对高级一些，也确实是这样C++对比C语言在某些地方处理的方式要比C语言先进一些，下面我们就来讲讲C++里面的新增的关键字

namespace关键字

这个关键字的意思是用来解决在编程中出现重复的变量名称的，在C/C++中，变量、函数，类都是⼤量存在的，这些变量、函数和类的名称将都存在于全局作⽤域中，可能会导致很多冲突。使⽤命名空间的⽬的是对标识符的名称进⾏本地化，以避免命名冲突或名字污染，namespace关键字的出现就是针对这种问题的相较于C语言，这就是优势
下面我们就具体来举列子来看看

namespace aaa
{
	int a = 0;
	int b = 1;
	int c = 2;
}

这里，我们新建了一个名字为aaa的作用域，也就是说在这个域里面定义的abc这个域里面的abc和全局或者其他域里面的拥有相同名字的abc的作用域是完全独立的，就行下面这样也是完全可行的，因为他们处于不同的作用域

namespace aaa
{
	int a = 0;
	int b = 1;
	int c = 2;
}
namespace bbb
{
	int a = 0;
	int b = 1;
	int c = 2;
}

同样在创建的作用域中，也可以不只定义变量，也可以定义函数，结构体等，还可以嵌套定义，就像下面这样，也是没问题的

namespace thh
{
	int a = 112;
	namespace other
	{
		int a = 134;
		int b = 987;
	}
	namespace ADD
	{
		int add(int a, int b)
		{
			return a + b;
		}
	}
	struct some
{
	int d = 90;
	int g = 66;
};
}

那么我们该怎么访问在作用域里面的定义呢？下面就来说说
这里我们要提到一个操作符了就是这个::这个操作符称为作用域解析操作符是用来我们访问作用域里面的元素用的，

namespace aaa
{
	int a = 0;
	int b = 1;
	int c = 2;
}
int main()
{
	cout << aaa::c << endl;
	return 0;
}

如果我们要访问aaa里面的元素c并把它打印出来，就要用到这个操作符，在::的右边是要选择的作用域，左边是作用域里面的元素,如果存在多个作用域的嵌套定义，可以像下面这样先是要访问作用域他的外围的作用域，在是这个作用域本身，然后是他里面要指定的元素，从外到内

namespace thh
{
	int a = 112;
	namespace other
	{
		int a = 134;
		int b = 987;
	}
	namespace ADD
	{
		int add(int a, int b)
		{
			return a + b;
		}
	}
	struct some
	{
		int d = 90;
		int g = 66;
	};
}
int main()
{
	cout << thh::other::a << endl;
	return 0;
}

同样如果在不同文件中存在多个相同名字的作用域，他们会自动合并成一个作用域，还有在**C++标准库都放在⼀个叫std(standard)的命名空间中。**这也就是为什么我们在写C++的时候要加一个这个代码

spacename std;

这个C++定义的作用域里面就包括了像C语言那些输出打印函数那一类类似的函数，我们需要调用他

命名空间的使用

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

1.指定命名空间访问，项⽬中推荐这种⽅式。
2.using将命名空间中某个成员展开，项⽬中经常访问的不存在冲突的成员推荐这种⽅式。
3.展开命名空间中全部成员，项⽬不推荐，冲突⻛险很⼤，⽇常⼩练习程序为了⽅便推荐使⽤

我们来写一个程序看看

# include <iostream>
using namespace std;
namespace a
{
	int b = 90;
}
int main()
{
	cout << b << endl;
	return 0;
}

如果我们去执行这个程序，就会报错，原因是找不到b这个变量，如果像这样就不会出现问题了

# include <iostream>
using namespace std;
namespace a
{
	int b = 90;
}
using a::b;//将作用域中的某一个成员展开
int main()
{
	cout << b << endl;
	return 0;
}

如果要展开全部成员就要像这样

using namespace a;

这样就全部展开了

C++的输入和输出

• 是 Input Output Stream 的缩写，是标准的输⼊、输出流库，定义了标准的输⼊、输
出对象。
• std::cin 是 istream 类的对象，它主要⾯向窄字符（narrow characters (of type char)）的标准输
⼊流。
• std::cout 是 ostream 类的对象，它主要⾯向窄字符的标准输出流。

• std::endl 是⼀个函数，流插⼊输出时，相当于插⼊⼀个换⾏字符加刷新缓冲区。

• <<是流插⼊运算符，>>是流提取运算符。（C语⾔还⽤这两个运算符做位运算左移/右移）

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

• IO流涉及类和对象，运算符重载、继承等很多⾯向对象的知识，这些知识我们还没有讲解，所以这
⾥我们只能简单认识⼀下C++ IO流的⽤法，后⾯我们会有专⻔的⼀个章节来细节IO流库。
• cout/cin/endl等都属于C++标准库，C++标准库都放在⼀个叫std(standard)的命名空间中，所以要
通过命名空间的使⽤⽅式去⽤他们。

• ⼀般⽇常练习中我们可以using namespace std，实际项⽬开发中不建议using namespace std。

• 这⾥我们没有包含<stdio.h>，也可以使⽤printf和scanf，在包含间接包含了。vs系列
编译器是这样的，其他编译器可能会报错。
我们来举个例子看看

# include <iostream>
using namespace std;
namespace a
{
	int b = 90;
	double c = 2.23456;
	char v = 'x';
}
int main()
{
	cout <<a::b<<" "<<a::v<<" "<<a::c << endl;
	return 0;
}

输出

这里我们发现，我们没有指定类型，但他可以正常按照我们想的进行输出，这是因为cout会自动识别类型，不用我们像C语言那样要自己去手动指定类型同意用cin输入也一样

缺省参数

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

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

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

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

我们来写一个程序看看

# include <iostream>
using namespace std;
void print(int a = 11)
{
	cout << a << endl;
}
int main()
{
	print();
	print(10);
	return 0;
}

这里我们给了函数一个缺省参数a= 11，我们在函数传参的时候并没有传任何参数，但还是打印出来了
如果我们在函数传参的时候传10或者9他打印出来的就是我们传的参数的值

全缺省和半缺省的区别

全缺省，就是在函数参数不分都给了一个默认值，半缺省就是只给了部分，注意：半缺省是有条件的必须是从左至右，中间不能空格

全缺省
void Func1(int a = 10, int b = 20, int c = 30)
{
//...............
}

半缺省
void func2(int b,int d = 20,int v = 30)
{
//..........
}  

还有缺省参数不能声明和定义同时给

函数重载

C++⽀持在同⼀作⽤域中出现同名函数，但是要求这些同名函数的形参不同，可以是参数个数不同或者
类型不同。这样C++函数调⽤就表现出了多态⾏为，使⽤更灵活。C语⾔是不⽀持同⼀作⽤域中出现同
名函数的。
这里相较于C语言，就太方便了，我们不用为了同一个函数返回不同类型而写两次
我们来举列子看看

#include<iostream>
using namespace std;
参数类型不同
int Add(int left, int right)
{
return left + right;
}
double Add(double left,double right)
{
 return left+right;
 }
参数个数不同
void func()
{
  cout<<"hello,world"<<endl;
}
void func(int a)
{
  cont<<a<<endl;
 }
参数类型顺序不同
void f(int a, char b)
{
cout << "f(int a,char b)" << endl;
}
void f(char b, int a)
{
cout << "f(char b, int a)" << endl;
}
还有一点重要，返回值不能作为区别条件
void fxx()
{
//.........
}

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

根据上面的例子我们应当注意函数重载的时候的一些小细节
好了以上就是本次的内容，剩下的关于引用会下次在补充。