c++入门

c语言是结构化和模块化的语言，适合处理较小规模的程序，不适合复杂编写。

c++、 面向对象语言，c++98是c++第一个标准版本

---

命名空间
通过范围限制，解决命名冲突。
对标识符的名称进行本地化，以避免命名冲突或名字污染
命名空间定义
使用namespace关键字，后面跟命名空间的名字，然后接一对{}即可
：：作用域限定符

int a=10;
namespace bit  
{
    int a=10;
}//现在不会有命名冲突，第一个a属于全局作用域,第二个a属于bit空间作用域
//命名空间可以嵌套使用
//命名空间也可以定义函数
//打印
printf("%d\n",a);
printf("%d"\n,bit::a);// 用两个：：使用！！！！
using bit::a;//使用using将命名空间中成员引入
using namespace bit //使用命名空间的名称引入 不建议,会造成命名空间污染

命名空间可以合并
定义相同的命名空间，编译器会自动合并

c++的输入&输出
使用cout标准输出（控制台），cin标准输入(键盘) 必须包含iostream,与std标准命名空间！
c++没有.后缀！！与c的头文件进行区分
使用c++输入输出更方便，不需要增加数据格式控制，整型%d 字符%c

#include <iostream>                   //std标准命名空间
void testIO()
{
    int i=10;
    int a,b;
    printf("i:%d\n",i);
    std::cin>>i;
    std::cout<<i;     //cout理解成嘴巴  i相当于说的话，从嘴巴里流
                     //自动判断数据类型
    std::cout<<i<<"hello world";
    std::cin>>i>>a>>b;  //依次从键盘输入到i a b;
    std::cout<<"\n";//换行
    std::cout<<a<<std::endl//换行                 
}

缺省参数
没有指定实参时，就执行默认值

void fun(int a=88)
{
    std::cout<<"fun(int)"<<std::endl;
}

int main()
{
    fun(10);
    fun();    
    return 0;
}

全缺省参数

void fun(int a=10,int b=10,int c=20)
{
    
}

半缺省参数

void fun1(int a,int b=10,int c=10)
{
    
}
void fun2(int a=10,int b,int c=30) //不合法！！！,从右边一次给参数赋值b没有值
//时a就不能有值

缺省参数，不能在函数声明与定义中同时出现！
只能有一个地方有默认值！！！

void fun3(int a=10,int b=10);//声明
void fun3(int a=10,int b=10)  //定义   非法！！！
{
    
}

函数重载
函数名相同，跟返回值类型无关，跟参数个数类型顺序有关
函数名相同，参数不同：1，类型不同 2，顺序不同 3，个数不同
c语言不支持函数重载，因为函数名修饰规则
c语言不支持函数重载，给函数名加个下划线，修饰比较简单
c++中加入了类与域，重新修饰成一个复杂的名称，不会产生混淆
c语言中底层函数名：_函数名
c++底层函数名： 前缀+函数名+参数

int Add(int a,int b)
{
    return a+b;
}
double Add(double a,double b，double c)
{
    return a+b;
}

名字修饰
预处理 汇编 编译 链接
预处理：去注释，宏替换，头文件展开
汇编：语法检查 源代码转换成汇编代码
编译：汇编代码---->转换成机器码
链接：机器码整合到一起生成机器指令，生成可执行程序

extern "c"
加入extern “C”表示按c语言编译规范去编译

extern “C”
{
    c语言代码
}//大括号里面按c语言编译

引用
引用不是定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟一个内存空间，它和它引用的变量共用同一块内存空间
（类型）&引用变量名=引用实体

int a=10;
int& ra=a;//共用同一块内存空间   定义引用类型
double& raa=a;//非法 a是int 不能double引用

引用特性
1.引用必须初始化
2.不同类型不能引用
3.指向一个实体后不会指向其他实体
4.一个变量可以有多个引用

常引用

const int a=8;
const int& ra=a;//常引用
const int& ra=100;//常引用

double d=2.0;
const int& rd=d;  //引用的是临时变量的空间  临时变量具有常性
//隐式转换
int c=d;  //隐式变量转换 内有临时变量产生！！！

引用
1.做参数 函数传指针,传引用效果一样
2.做返回值（生命周期不能结束！！）

int& Add(int a,int b)
{
    int c=a+b;
    return c;
}
int main()
{
    int& ret=Add(1,3);//执行函数晚，函数释放，局部变量，生命周期结束！
    cout<<"Add(1,3):"<<ret<<endl;//
    //出现的是随机值
}

传值，传引用效率比较
传值只是拷贝，传引用是本身
引用的底层层面：引用开辟新的空间，和指针的实现相同(汇编看)

引用与指针
1.引用必须初始化，指针没有必要要求
2.没有NULL引用，有NULL指针
3.一个变量可以有多个引用，一个引用只能引用一个变量
4.在sizeof的含义不同，引用结果为引用类型的大小，指针始终是地址空间所占字节个数
5.引用自加即引用实体的增加1，指针自加即指针向后偏移一个类型的大小
6.有多级指针，没有多级引用。
7.指针需要显式解引用，引用编译器自己处理

内联函数
以inline修饰的函数叫内联函数（效率比较高），编译的时候直接展开函数体，没有函数栈针的开销
相当于编译的代码变多了，空间换时间！

内联函数特性
1.inline是一种空间换时间的做法，省去调用函数开销，所以代码很长或循环、递归的函数不适应作为内联函数。
2.inline函数的定义与声明要放在一起！！防止报错
3.inline对于编译器而言只是一个建议，编译器会自动优化