C++入门（上）

 致力于将c++学透彻的第一天

一、C++命名空间

在C/C++中，变量、函数和后面要学到的类都是大量存在的，这些变量、函数和类的名称将都存在于全局作用域中，可能会导致很多冲突。使用命名空间的目的是对标识符的名称进行本地化，以避免命名冲突或名字污染，namespace关键字的出现就是针对这种问题的。

先来一段c语言的命名冲突代码

#include<stdio.h>
#include<stdlib.h>

int rand=10;

int main()
{
  printf("%d",rand);
  return 0;

}
// 编译后后报错：error C2365: “rand”: 重定义；以前的定义是“函数”

 1.1命名空间的定义

     规则：定义命名空间，需要使用namespace关键字，后面跟命名空间的名字，然后别忘了大括号{}，{}中即是命名空间的成员。

//bit是命名空间的名字，一般在开发中是用项目名字做命名空间
namespace bit
{
 // 命名空间中可以定义变量/函数/类型
 int rand = 10;
 int Add(int left, int right)
 {
 return left + right;
 }
 struct Node
 {
 struct Node* next;
 int val;
 };
}
//2. 命名空间可以嵌套
// 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;
     }
 }
}
//3. 同一个工程中允许存在多个相同名称的命名空间,编译器最后会合成同一个命名空间中。
// ps：一个工程中的test.h和上面test.cpp中两个N1会被合并成一个
// test.h
namespace N1
{
int Mul(int left, int right)
 {
     return left * right;
 }

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

1.2命名空间的使用

错误的使用：

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;
}

 命名空间的正确使用方式：

(1）加命名空间名称及作用域限定符(::)

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

(2)使用using 将某个成员引入

using N::b;
int main()
{
    printf("%d",b);//此时，b的值就是N空间中定义的值了
}

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

using namespace N;
int main()
{
   printf("%d",b);
   Add(10,20);
    return 0;
}

注意：在正式的项目中，不要像这样来展开命名空间

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

补充：；namespace 支持套娃，在我们调用的时候，也可以重叠使用  bits::zs::push();

二、 C++的输入和输出

 注意，不同于C语言：<<在C++中有两个含义：1、左移运算符  2、流插入运算符

说明：

1. 使用cout标准输出对象(控制台)和cin标准输入对象(键盘)时，必须包含< iostream >头文件以及按命名空间使用方法使用std。
2. cout和cin是全局的流对象，endl是特殊的C++符号，表示换行输出，他们都包含在包含< iostream >头文件中。
3. <<是流插入运算符，>>是流提取运算符。
4. 使用C++输入输出更方便，不需要像printf/scanf输入输出时那样，需要手动控制格式。C++的输入输出可以自动识别变量类型。
5. 实际上cout和cin分别是ostream和istream类型的对象，>>和<<也涉及运算符重载等知识，
ps：更深入的IO流用法及原理在后面。

#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;
}

三*缺省参数

3.1缺省参数的概念

缺省参数的声明或定义函数时的参数指定的一个缺省值，在调用该函数时，如果没有指定实参，则采用该形参的缺省值，否则使用指定的实参（形象的比喻：缺省=天狗）

#include<iostream>
using namespace std;
void func(int a=0)
{
    cout<<a<<endl;
}
int main()
{
   func();//没有传参数时，那就去用缺省参数
   func(10);//传参了，则用传入指定的参数
    return 0;
}
//输出
//0
//10

3.2 缺省参数的分类

全缺省参数

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

半缺省参数

void Func(int a, int b = 10, int c = 20)
 {
     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)
 {}
  
  // 注意：如果生命与定义位置同时出现，恰巧两个位置提供的值不同，那编译器就无法确定到底该用那个缺省值。

3、缺省值必须是常量或者全局变量

4、C语言不支持缺省的

四、函数重载

4.0 前置知识（重要）

计算机在执行一段代码之前会进行以下四步操作

预处理->编译->汇编->链接

预处理：展开头文件/宏替换/条件编译/去注释

编译：检查语法

汇编：把编译代码转成二进制机器码

链接：合并到一起

编译器调用函数时，是靠函数的地址来找到函数的

函数的地址==函数内一堆指令的第一个地址（类比数组）

同时，只有函数定义了，才能有地址！

定义与声明的区别：定义是具体写出了函数内部的功能结构，而声明只是给出了函数名和参数

借钱--答应转账=声明  ；  已经转账=定义

 记住以上知识，一会会用到

4.1 什么是函数重载

函数重载：是函数的一种特殊情况，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;
}

4.2 C++为什么要有重载

当声明和定义分离的时候，会出现问题

C语言中：链接时，直接用函数名去找地址，当有同名函数出现时，区分不开

所以C++改进，引入了函数名修饰规则，函数名字中引入了参数类型

4.3 C++支持函数重载的原理

1. 实际项目通常是由多个头文件和多个源文件构成，而通过C语言阶段学习的编译链接，我们可以知道，【当前a.cpp中调用了b.cpp中定义的Add函数时】，编译后链接前，a.o的目标文件中没Add的函数地址，因为Add是在b.cpp中定义的，所以Add的地址在b.o中。那么怎么办呢？

2. 所以链接阶段就是专门处理这种问题，链接器看到a.o调用Add，但是没有Add的地址，就会到b.o的符号表中找Add的地址，然后链接到一起。

3. 那么链接时，面对Add函数，链接接器会使用哪个名字去找呢？这里每个编译器都有自己的函数名修饰规则。

在linux的环境下测试发现，gcc的函数修饰（改变形参列表）后名字不变。而g++的函数修饰后变成【_Z+函数长度+函数名+类型首字母】。

Windows下的名字修饰规则（了解即可）