C++基础语法之重载引用和命名空间等

1.C++关键字

c++的关键字比我们的c语言的关键字多，c++包容C语言并对C语言进行了补充，但是我们对关键字的学习是在我们后面逐渐学习的。这里我们的只是提供一个表格对齐了解一下。

2.命名空间

我们c++出现了命名空间的概念，用关键字namespace来定义。他主要是补充了C语言的变量名字重复的问题。C/C++中，变量、函数和后面要学到的类都是大量存在的，这些变量、函数和类的名称将都存 在于全局作用域中，可能会导致很多冲突。使用命名空间的目的是对标识符的名称进行本地化， 以避免命名冲突或名字污染。

命名空间的定义：

namespace + 空间名字+{

//可以定义我们变量，函数结构体。

}

例如：

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

}

我们在写项目的时候的一般用项目名字的简写来命名空间。

我们的命名空间还可以嵌套。

如：

//test.cpp

namespace N1
{
 int a;
 int b;
 int Add(int left, int right)
 {
     return left + right;
 }
 namespace N2
 {
     int c;
     int d;
     int Sub(int left, int right)
     {
         return left - right;
     }
 }
}

 同一个工程中允许存在多个相同名称的命名空间,编译器最后会合成同一个命名空间中。

 一个工程中的test.h和上面test.cpp中两个N1会被合并成一个

// test.h
namespace N1
{
 int Mul(int left, int right)
 {
     return left * right;
 }
}

 我们的命名空间是一个新的作用域，他比我们的C语言的 多了一个作用域（全局作用域和局部作用域）。我们的命名空间中的所有内容都局限于该命名空间中

命名空间的使用：

namespace bit
{
 // 命名空间中可以定义变量/函数/类型
 int a = 0;
 int b = 1;
 int Add(int left, int right)
 {
 return left + right;
 }
 struct Node
 {
 struct Node* next;
 int val;
 };
}
int main()
{
 // 编译报错：error C2065: “a”: 未声明的标识符
 printf("%d\n", a);
 return 0;
}

 我们这里的a 是没有定义的，因为这里的命名空间是一个私有的域，，如果我们不进行的命名空间展开的话，我们是没办法访问这块空间的，所以这里我们是找不到的a的。

但是在做项目的时候，我们的命名空间全部展开的话是不太好的：

命名空间可以解决命名冲突问题，因为它们允许在不同的作用域中定义相同名字的实体。如果命名空间被展开，那么原本被隔离的命名空间中的实体可能会与外部的实体发生冲突。

所以我们可以只展开我们要用到的。在我们平时写作业时我们可以全部展开的，就像我们展开我们的我们c++提供的标准库。

命名空间的使用有三种方式：

1 加命名空间名称及作用域限定符（：：）

int main()
{
    printf("%d\n", N::a);
    return 0;    
}

2 使用using将命名空间中某个成员引入

只展开了我们要用的。

using N::b;
int main()
{
    printf("%d\n", N::a);
    printf("%d\n", b);
    return 0;    
}

3 使用using namespace 命名空间名称 引入

这里是全部展开

using namespce N;
int main()
{
    printf("%d\n", N::a);
    printf("%d\n", b);
    Add(10, 20);
    return 0;    
}

在我们这里我们如果我们的全局变量和局部比那里那个都有的同一个变量，我们是采取就近原则，局部优先，再是全局，如果我们的命名空间也有的话，并且我们的全局变量也同样存在，我们也展开我们的命名空间的话，（局部变量没有），那这里就会导致我们的报错不会通过，访问冲突了。

3.C++输入&输出

先看一个例子：

#include<iostream>
// std是C++标准库的命名空间名，C++将标准库的定义实现都放到这个命名空间中
using namespace std;
int main()
{
cout<<"Hello world!!!"<<endl;
return 0;
}

 说明：

1. 使用cout标准输出对象(控制台)和cin标准输入对象(键盘)时，必须包含< iostream >头文件 以及按命名空间使用方法使用std。

2. cout和cin是全局的流对象，endl是特殊的C++符号，表示换行输出，他们都包含在包含< iostream >头文件中。

3. 是流插入运算符，>>是流提取运算符。

4. 使用C++输入输出更方便，不需要像printf/scanf输入输出时那样，需要手动控制格式。 C++的输入输出可以自动识别变量类型。

5. 实际上cout和cin分别是ostream和istream类型的对象，>>和也涉及运算符重载等知识。

#include <iostream>
using namespace std;
 
int main()
{
   int a;
   double b;
   char c;
     
   // 可以自动识别变量的类型
   cin>>a;
   cin>>b>>c;
     
   cout<<a<<endl;
   cout<<b<<" "<<c<<endl;
   return 0;
}

 我们这里的有里的一个优点是可以进行这里会自动识别变量类型。

endl是可以进行换行的，我们也可以这样：cout<<b<<" "<<"\n"<<endl;

using namespace std展开，标准库就全部暴露出来了，如果我们定义跟库重名的类型/对 象/函数，就存在冲突问题。该问题在日常练习中很少出现，但是项目开发中代码较多、规模 大，就很容易出现。所以建议在项目开发中使用，像std::cout这样使用时指定命名空间 + using std::cout展开常用的库对象/类型等方式。

4. 缺省参数

定义：

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

void Func(int a = 0)
{
 cout<<a<<endl;
}
int main()
{
 Func();     // 没有传参时，使用参数的默认值
 Func(10);   // 传参时，使用指定的实参
 
 return 0;
}

 我们使用缺省参数的时候可以不传参数，使用默认参数。

缺省参数分类

1 全缺省

void Func(int a = 10, int b = 20, int c = 30)
 {
     cout<<"a = "<<a<<endl;
     cout<<"b = "<<b<<endl;
     cout<<"c = "<<c<<endl;
 }

2 半缺省

void Func(int a , int b = 20, int c = 30)
 {
     cout<<"a = "<<a<<endl;
     cout<<"b = "<<b<<endl;
     cout<<"c = "<<c<<endl;
 }

   注意： 1. 半缺省参数必须从右往左依次来给出，不能间隔着给

   2. 缺省参数不能在函数声明和定义中同时出现  

//a.h
  void Func(int a = 10);
  
  // a.cpp
  void Func(int a = 20)
 {}
  
  // 注意：如果生命与定义位置同时出现，恰巧两个位置提供的值不同，那编译器就无法确定到底该
用那个缺省值

函数缺省这一功能对于我们不知道一个参数要传什么时，我们可以不传，，还是很方便。

5. 函数重载

函数的重载是指：是函数的一种特殊情况，C++允许在同一作用域中声明几个功能类似的同名函数，这 些同名函数的形参列表(参数个数 或 类型 或 类型顺序)不同，常用来处理实现功能类似数据类型 不同的问题。不能是返回值不同，因为我们的返回值可以不进行接受，南无我们就不知道是哪一个函数了，

例子：

#include<iostream>
using namespace std;
// 1、参数类型不同
int Add(int left, int right)
{
 cout << "int Add(int left, int right)" << endl;
 return left + right;
}
double Add(double left, double right)
{
 cout << "double Add(double left, double right)" << endl;
 return left + right;
}
// 2、参数个数不同
void f()
{
 cout << "f()" << endl;
}
void f(int a)
{
 cout << "f(int a)" << endl;
}
// 3、参数类型顺序不同
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;
}
int main()
{
 Add(10, 20);
 Add(10.1, 20.2);
 f();
 f(10);
 f(10, 'a');
 f('a', 10);
 return 0;
}