C++基础（一）

命名空间

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

命名空间的定义：

定义命名空间，需要用到namespace关键字，后面跟命名空间的名字，然后接{}，{}中即为命名空间的成员。

//普通命名空间
namespace N1
{
    int a = 0;
    int Add(int x, int y);
    {
           return x+y;
    }
}

//嵌套的命名空间
namespace N2
{
      int a;
      int b;
      int Add(int x, int y)
      {
           return x+y;
      }
  namespace N3
  {
       int c;
       int d;
       int Sub(int x, int y)
       {
            return x-y;
       }
  }
}    

//同一个工程中可以出现相同名称的命名空间
//编译器最后会合成同一个命名空间
namespace N1
{
    int Mul(int x, int y)
    {
         return x*y;
    }

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

使用命名空间

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 namespace N;
int main()
{
    printf("%d\n",N::a);
    printf("%d\n", b);
    Add(10, 20);
    return 0;
}

C++输入/输出

#include <iostream>
using namespace std;

int main()
{
   cout<<"hello world!"<<endl;
   return 0;
}

1. 使用cout标准输出和cin输入输入时，必须包含头文件以及std标准命名空间。
2. 使用C++输入输出更方便，不需要增加格式控制。

#include <iostream>
using namespace  std;
{
   int a;
   double b;
   char c;
   
   cin>>a;
   cin>>b>>c;
   
   cout<<a<<endl;
   cout<<b<<" "<<c<<endl;
   

缺省参数

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

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

int main()
{
    TestFunc();// 没传参数时，使用参数的默认值
    TestFunc(10); // 传参数时，使用指定的实参
 }

缺省参数又分为以下三类：

• 全缺省参数

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

• 半缺省参数

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

}

注意：1.半缺省参数必须从右往左依次给出，不能间隔着给。
2.缺省参数不能在函数声明和定义中同时出现。
3.缺省值必须是常量或者全局变量。
4.C语言不支持缺省参数。

函数重载

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

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

double Add(double x, double y)
{
    return x+y;
}

long Add(int x, int y)
{
   return x+y;
}


int main()
{
    Add(1, 2);    
    Add(1.0, 2.0);
    Add(1L, 2L);
    
    return 0;

}

名字修饰（Name Mingling）：Name Mingling是一种在函数编译过程中，将函数，变量的名称重新改编的机制，简单来说就是编译器为了区分各个函数，将函数通过某种算法，重新修饰为一个全局唯一的名称。

extern “C"：有时候在C++工程中可能需要将某些函数按照C的风格来编译，C++不能直接调用C函数，在函数前加extern“C”,意思告诉编译器，将该函数按C语言规则来编译。

例如：

extern "C"
{
        void Add(int x, int y);
        ...
 }
或者
extern "C"
{
      #include "header.h";
      ...
}

特别的：并不是函数名称相同就能构成重载。比如全局函数和成员函数同名就不能算重载，因为函数的作用域不同

void Print()；        //全局函数

class A
{
    void Print();       //成员函数
}
无论两个函数是否相同，如果成员函数要调用全局函数Print，
为了区别与成员函数的差别，全局函数在被调用时应该加上::的标志，
如：::Print()表示全局函数而不是成员函数。

引用

概念：引用不是新定义一个变量，而是给一个已存在的变量取了一个别名，编译器不会为了引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。

类型& 引用对象名（对象名）=引用实体

void TestRef()
{
    int a=10;
    int& b=a;//定义引用类型
    
    printf("%d\n",&a);
    printf("%d\n",&b);
}

特别的：引用类型必须和引用实体是同种类型的。

引用的特性：

1. 引用在定义时必须初始化

int a=10;
int& b=a;
//int& b;-->该条语句是错误的

2. 一个变量可以有多个引用。
3. 引用一旦引用实体，再不能引用其他实体。

常引用：

void TestConstRef()
{
  const int a = 10;
  //int& b = a; 该语句编译时会出错，a为常量
  const int& b = a;
  //int& b = 10;  该语句编译时会出错，b为常量
  const int& b = 10;
  double d = 13.14;
  //int& rd = d;  编译出错，类型不同
  const int& rd = d;
   
}

引用使用场景
1.做参数
2.做返回值

注意：如果函数返回时，离开作用域后，其栈上空间已经还给系统，因此不能用栈上的空间作为引用类型返回。如果以引用类型返回，返回值的生命周期必须不受函数限制（即比函数生命周期长）。

传值，传引用的效率比较

实际上，通过测试，引用和指针在作为传参以及返回值类型上效率几乎相同。

引用和指针的区别

在语法概念上引用就是一个别名，没有独立空间，和其引用实体共用同一块空间。
在底层实现上实际是有空间的，因为引用是按指针方式来实现的。

引用与指针的不同点：

• 引用在定义时，必须初始化，指针没有要求。
• 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体。
• 没有NULL引用，但有NULL指针。
• 在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数（32位平台下占4个字节，64位平台下8个字节）。
• 引用自加即引用实体增加1，指针自加即指针向后偏移一个类型大小。
• 有多级指针，但没有多级引用。
• 访问实体方式不同，指针需要显式解引用，引用编辑器自己处理。
• 引用比指针使用起来相对安全。