😜前言😜

C++是在C语言的基础上，容纳进去了面向对象编程思想，并增加了许多库，以及编程范式等。

😛C++关键字😛

C++总计63个关键字，C语言32个关键字

C++关键字>

🐸 命名空间 🐸

假设这样一种情况，当一个班上有两个名叫 Zara 的学生时，为了明确区分它们，我们在使用名字之外，不得不使用一些额外的信息，比如他们的家庭住址，或者他们父母的名字等等。

同样的情况也出现在 C++ 应用程序中。例如，您可能会写一个名为 xyz() 的函数，在另一个可用的库中也存在一个相同的函数 xyz()。这样，编译器就无法判断您所使用的是哪一个 xyz() 函数。

因此，引入了命名空间这个概念，专门用于解决上面的问题，它可作为附加信息来区分不同库中相同名称的函数、类、变量等。使用了命名空间即定义了上下文。本质上，命名空间就是定义了一个范围。

我们举一个计算机系统中的例子，一个文件夹(目录)中可以包含多个文件夹，每个文件夹中不能有相同的文件名，但不同文件夹中的文件可以重名。

我们来举个例子>

#include<stdio.h>
#include<stdlib.h>
int rand = 10;
int main()
{
  printf("%d",rand);
  return 0;
}

这段代码正常逻辑会打印‘10’，我们来运行一下看看>

我们可以看到代码出现错误了，报错显示rand重定义，这是因为rand与<stdlib.h>中的rand函数重名了，所以编译器才会给出报错。

那么为了结果以上这种问题我们来引入命名空间。

命名空间的定义

定义命名空间，需要使用到namespace关键字，后面跟命名空间的名字，然后接一对{}即可，{}中即为命名空间的成员。（后面不用加‘;’）

来看代码>

1. namespace name {
2. // 代码声明
3. }

代码声明可以定义属于name空间域的变量，如果需要访问name空间域的变量或函数则需要>

1. name::code;  // code 可以是变量或函数
2. //::是域作用限定符

再来看具体的实例>

#include <iostream>
using namespace std;
// 第一个命名空间
namespace first_space {
    void func() {
        cout << "first_space" << endl;
    }
}
// 第二个命名空间
namespace second_space {
    void func() {
        cout << "second_space" << endl;
    }
}
int main()
{
    // 调用第一个命名空间中的函数
    first_space::func();
    // 调用第二个命名空间中的函数
    second_space::func();
    return 0;
}

代码执行结果>

当然命名空间域也可以嵌套定义>

//命名空间嵌套
namespace N1
{
    int a = 0;
    int b;
    int Add(int left, int right)
    {
        return left + right;
    }
    namespace N2
    {
        int a = 1;
        int c;
        int d;
        int Sub(int left, int right)
        {
            return left - right;
        }
    }
}
int main()
{
    //访问N1里的变量
    printf("%d\n", N1::Add(1, 2));
    //访问N1里的N2的变量
    printf("%d\n", N1::N2::Sub(5,4));
    return 0;
}

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

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

⚠注意：一个命名空间就定义了一个新的作用域，命名空间中的所有内容都局限于该命名空间中

命名空间的使用"using指令"

我们有这么一段代码>

namespace N
{
  // 命名空间中可以定义变量/函数/类型
  int a = 0;
  int b = 1;
  int Add(int left, int right)
  {
    return left + right;
  }
  struct Node
  {
    struct Node* next;
    int val;
  };
}

如果我们想要访问里面的变量a我们可以通过以下3种方法来进行访问。

1.加命名空间名称及作用域限定符

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

2.使用using将命名空间中a成员引入

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

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

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

小结：

int a = 1;
namespace XZ {
  int a = 10;
}
int main()
{
  int a = 0;
  printf("%d\n", a);    //访问局部变量
  // ::域作用限定域
  printf("%d\n",::a);   //访问全局变量
  printf("%d\n", XZ::a);//访问命名空间变量
  return 0;
}

变量作用域访问的先后顺序是：局部域->全局域 -> 展开了命名空间域 or 指定访问命名空间域

😺C++输入&输出😺

C++ 标准库提供了一组丰富的输入/输出功能，C++ 的 I/O 发生在流中，流是字节序列。如果字节流是从设备（如键盘、磁盘驱动器、网络连接等）流向内存，这叫做输入操作。如果字节流是从内存流向设备（如显示屏、打印机、磁盘驱动器、网络连接等），这叫做输出操作。

C++输出

#include <iostream>
// std是C++标准库的命名空间名，C++将标准库的定义实现都放到这个命名空间中
using namespace std;
int main()
{
  char str[] = "Hello C++";
  cout << "Value of str is : " << str << endl;
}

上面的代码被编译和执行时，它会产生下列结果：

C++ 编译器根据要输出变量的数据类型，选择合适的流插入运算符来显示值。<< 运算符被重载来输出内置类型（整型、浮点型、double 型、字符串和指针）的数据项。

流插入运算符 << 在一个语句中可以多次使用，如上面实例中所示，endl 用于在行末添加一个换行符。

C++输入

#include <iostream>
using namespace std;
int main( )
{
   char name[50];
   cout << "请输入您的名称： ";
   cin >> name;
   cout << "您的名称是： " << name << endl;
}

C++ 编译器根据要输入值的数据类型，选择合适的流提取运算符来提取值，并把它存储在给定的变量中。流提取运算符 >> 在一个语句中可以多次使用，如果要求输入多个数据，可以使用如下语句：

cin >> name >> age;

相当于：

1. cin >> name;
2. cin >> age;

std命名空间的使用惯例：

std是C++标准库的命名空间，如何展开std使用更合理呢？

在日常练习中，建议直接using namespace std即可，这样就很方便。

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

😃缺省参数😃

什么是缺省参数？

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

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

运行结果>

缺省参数的两种类型

全缺省参数

//全缺省参数
void Func(int a = 10, int b = 20, int c = 30)
{
  cout << "a= " << a << endl;
  cout << "b= " << b << endl;
  cout << "c= " << c << endl;
  printf("\n");
}
int main()
{
  Func();
  Func(1);
  Func(1.2);
  Func(1, 2, 3);
  return 0;
}

半缺省参数

//半缺省参数
void Func(int a, int b = 10, int c = 20)
{
  cout << "a= " << a << endl;
  cout << "b= " << b << endl;
  cout << "c= " << c << endl;
  printf("\n");
}
int main()
{
  Func(0);
  Func(0, 1);
  Func(0, 1, 2);
  return 0;
}

总结：

半缺省参数必须从右王座一次来给出，不能间隔着给
缺省参数不能再函数声明和定义中同时出现（在声明中）
缺省参数必须是常量或者全局变量

🙈函数重载🙈

什么是函数重载？

函数重载：是函数一种特殊的情况，c++中允许在同一作用域中声明几个功能类似的同名函数，这些同名函数的形参列表（参数个数/类型/类型顺序）不同，常用来处理实现功能类似数据类型不同的问题。

函数重载的几种形式

1.参数个数不同

//1.参数个数不同
int Func()
{
  return -1;
}
int Func(int x)
{
  return x;
}
int Func(int x, int y)
{
  return x + y;
}
int main()
{
  cout << Func() << endl;
  cout << Func(5) << endl;
  cout << Func(1,2) << endl;
  return 0;
}

2.参数类型不同

//2.参数类型不同
int Add(int x, int y)
{
  cout << "int Add(int x, int y)" << endl;
  return x + y;
}
double Add(double x, double y)
{
  cout << "double Add(double x,double y)" << endl;
  return x + y;
}
int main()
{
  cout << Add(1, 2) << endl;
  cout << Add(1.1, 1.2) << endl;
  return 0;
}

3.参数类型顺序不同

//3.参数类型顺序不同
void f(int x, char y)
{
  cout << "void f(int x,char y)" << endl;
}
void f(char x, int y)
{
  cout << "void f(char x,int y)" << endl;
}
int main()
{
  f(1, 1.1);
  f(1.1, 1);
  return 0;
}

🍀小结🍀

今天我们认识了C++关键字、学习了命名空间、输入输出、缺省函数、函数重载相信大家看完有一定的收获。

C++入门上（关键字、命名空间、输入输出、缺省参数、函数重载）