c++基础语法

前言

大家好我是jiantaoyab，这篇文章给大家带来的是c语言没有的一些特性之一，是c++的基础语法，对后面的学习有帮助，后面我将逐步编写类和对象、STL容器等C++笔记，欢迎大家关注我！

命名空间

当程序达到一个规模后，会不可避免的使用到相同的函数名和标识符导致冲突，可以使用namespace封装到一个命名空间中，一个命名空间就定义了一个新的作用域，命名空间中的所有内容都局限于该命名空间中

同一个工程中能存在相同的命名空间，相同名字的命名空间会合并到一起

作用域:变量的有效范围，从定义的起点开始，到定义变量之前最近的一对括号确定

命名空间的使用

//1.使用using使用命名空间成员之一
using jiantao::n;
//2.using namespace jiantao
//全部展开，失去封装的效果，不建议这样使用
namespace jiantao
{int n = 10;//可以嵌套使用namespace id{int b = 2;}
}int main()
{cout << n << endl; //using jiantao::n; 直接用cout << jiantao::n << endl; //一般的使用方法cout << jiantao::id::b << endl; return 0;
}

缺省参数

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

缺省参数的使用

注意点

• 半缺省参数必须从右往左给，不能间隔给
• 缺省参数不能在定义和声明中同时出现，建议在声明中写
• 缺省值必须是全局变量或者是常量

void fun()
{cout << "fun()" << endl;
}//默认这里的参数会给值
void fun(int a ,int b=10,int c=20)
{cout << a << endl;cout << b << endl;cout << c << endl;}
int main()
{fun(1); fun(1,2);//传2的话b的值就是2
}

函数重载

函数重载是指在同一作用域内，声明几个功能类似的同名函数，这些同名函数的形参列表(参数个数 或 类型 或 顺序)必须不同，这组函数被称为重载函数

函数重载的作用

重载函数通常用来命名一组功能相似的函数，这样做减少了函数名的数量，避免了名字空间的污染，对于程序的可读性有很大的好处

函数重载的使用

int add(int a, int b)
{return a + b;
}
double add(double a, double b)
{return a + b;
}
int main()
{add(1, 2);add(1.1, 1.2); //2个add构成重载return 0;
}

函数重载原理

Linux下，我定义了2个函数名字相同的函数，在gcc编译的时候，报错

什么原因？

回忆一下一个程序编译链接的过程，在汇编的时候，会生成.o文件，.o文件是没有函数的地址的（声明和定义分开写），那么在链接的时候，会根据函数的名字去找地址，而在c语言中，不存在函数名字的修饰，根据函数的名字去符号表中找，假设在符号表中有Add(0x33123)和Add(0x332323)，这在符号表中都冲突了，人家链接也不知道链接哪个

而在c++中，存在函数名修饰规则，不同平台下不一样，在linux下大概为作用域+返回类型+函数名+参数列表，就能找到的函数的地址能链接上了

重载大概的流程图

我的知识有限，大家可以看看这篇 c++函数重载 里面有更详细的介绍

引用

引用不是新定义一个变量，而是给已经存在的变量起了一个别名，引用的变量和原来的变量共用一块内存空间

引用的使用

1.引用的类型和引用的实体必须的同类型的int a=10; int &b=a;2.引用在定义的时候必须初始化int &c=10 //error 引用的必须是一个对象const int a=10; int &b=a;//error a为常量
3.一旦一个引用被初始化指向一个对象，它就不能变为另一个对象的引用但一个对象可以有多个引用int a = 0;int& b = a;int& b = c; //ERRORint& c = a; //RIGHT
4.引用权限只能缩小，不能放大int a=10;const int &b=a;//✔ 权限缩小const int d = 10;int & f = d; //ERROR，这是权限的放大
5 临时变量本来是右值，是常量不能修改的double b = 1.1;int& i = d; //ERROR，存在类型转换，类型转换有临时变量const int& i2 = d //可以 

引用的使用场景

1.引用做参数 ：提高效率,形参的改变能影响实参
int swap(int &x,int &y)
{}
使用引用传参，如果不改变参数的值，建议使用const引用2.引用做返回值：提高效率，修改返回变量（临时变量本来是右值，是常量不能修改的）
int& Add(int a,int b)
{int c=a+b; return c;
}
int main()
{int ret=Add(1,2);cout<<ret<<endl;
}

引用做返回值有一个重要的点，引用的这个返回对象在这个函数栈帧销毁的时候，还存在着才能使用引用返回。

int& Sub(int x, int y)
{int ret = x - y;return ret;
}int& f()
{int *p=(int *)malloc(4);return *p;//是可以的，p指向的空间还在return p;//error 指针p已经给销毁
}
int main（）
{int& a = Sub(2, 1);
}  

虽然编译通过了，但是上面的代码会存在非法访问的问题，Sub的返回值原来是临时变量，这里用了引用返回，那相当于int & ret = tmp，在调用完Sub后会回去访问ret的空间，假如Sub栈帧给销毁了，a所取到的值就是随机值，这里我们并没有马上使用这块空间才没报错。

引用和指针

• 引用在定义的时候必须初始化，指针不初始化也不报错
• 引用一个对象之后就不能再引用别人对象，指针可以随意更改对象
• 引用的大小是引用实体的大小，指针的大小是固定是4/8个字节
• 引用不会开辟空间不占用内存
• 引用加1是引用的实体加1，指针加1是向后偏移一个类型的大小

通过下面的汇编代码看出，引用和指针在使用的汇编指令是一样的

extern C

大家有没有想过，如果我用c++写的程序，想去调用别人c写的库怎么去调用呢？

一会再回答这个问题，我们先来看看extern的用法。

extern是C语言中的一个关键字，一般用在变量名前或函数名前，作用是用来说明此变量/函数是在别处定义的，要在此处引用，在遇到此变量或函数的时候在其他文件中寻找其定义

extern int a;//声明变量a是在别的文件定义的，只是声明，没有分配内存
举个例子：   
比如我在test.cpp中 extern int num; extren void Print();
然后在fun.cpp 中  
int num = 1; //这里是定义变量  
void Print(){printf("Print()");} //这里是定义函数
这样子就能在test.cpp中使用这个num变量了 和 Print 这个函数了

想要在C++中调用c语言写的库，在vs2013下，需要执行下面操作

1. 调试->属性->链接器 常规 ->附加库目录把库加上（Debug）

2. 调试->属性->链接器 输入-> 附加依赖项 手动加入库的名字 xxx.lib

extern "C"
{//把头文件所在的目录包含#include "../../DS/DS/Stack.h" 
}

告诉C++编译器，extern “C”{}里面的函数是C编译器编译的，链接的时候用C的函数名规则去找，就可以链接上, 定义为extern的变量也会在外面去找

在C中调用c++写的库，要在cpp库中修改

//如果有__cplusplus 这个宏就用 extern "C" 替换 EXTRERN_C
#ifdef __cplusplus
#define EXTRERN_C extern "C" // C++静态库extern "C"告诉编译器以下函数按C的函数名修饰规则去处理
#else
#define EXTRERN_C  //这里走的是else 就是EXTRERN_C 什么都没有
#endifEXTRERN_C void StackInit(ST* ps); //运行后相当于 void StackInit(ST* ps)
EXTRERN_C void StackDestroy(ST* ps);
EXTRERN_C void StackPush(ST* ps, STDataType x);
EXTRERN_C void StackPop(ST* ps);
EXTRERN_C STDataType StackTop(ST* ps);
EXTRERN_C int StackSize(ST* ps);
EXTRERN_C bool StackEmpty(ST* ps);

inline

以inline修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开，没有函数压栈的开销（使用内联函数在.o文件符号表不会生成函数的地址），内联函数提升程序运行的效率。

一般调用函数在汇编语言中是用call来调用的

当把Add函数设置成内联函数后,再看看汇编，想要显示出效果需要在vs2013Debug下设置

可以看到直接以函数的本体代替就像宏一样，但是会增加目标码的大小，会导致额外的换页行为，降低指令高速缓存装置的击中率。还有要注意的是inline只是对编译器的一个申请，不一定会采用

还有inline不建议声明的定义分离，分离会导致链接错误在小型、频繁调用的函数上，可以使用inline

小练习

A.使用inline关键字的函数会被编译器在调用处展开
B.头文件中可以包含inline函数的声明
C.可以在同一个项目的不同源文件内定义函数名相同但实现不同的inline函数

A.不一定，因为inline只是一种建议，需要看此函数是否能够成为内联函数

B. inline函数不支持声明和定义分离开，因为编译器一旦将一个函数作为内联函数处理，就会在调用位置展开，即该函数是没有地址的，也不能在其他源文件中调用，故一般都是直接在源文件中定义内联函数的

C.inline函数会在调用的地方展开，所以符号表中不会有inline函数的符号名，不存在链接冲突。

auto

自动推导类型：类型声明时的“占位符”，编译器在编译期会将auto替换为变量实际的类型 ，auto会忽略顶层的const，而底层const被保留（顶层const是指针本身是个 常量，底层const是指针指向的对象是一个常量）

int main()
{const int a = 10;auto b = a; // int cout << typeid(b).name() << endl;//不管原来对象是不是const 要想成为const的auto 要在 auto前加上const //例如 const auto b =a； 这样定义出来的b就是带const属性的int x = 1;auto a = x; //intauto&b = x; //int&auto*c = &x;//int *return 0;
}

auto不能使用的场景

1.不能作为函数的参数
void Add(auto a) //error 编译器无法对a的实际类型进行推导
auto b //error
2.不能用来声明数组
auto arr[]={1,2,3}; //error    

范围for

int main()
{int arr[] = { 1, 2, 3, 4, 5, 6, 7 };//范围for这个地方必须是数组名for (auto e: arr) //一个一个取arr的值放到e中{cout <<" "<< e; }cout << endl;//每个值加1for (auto&e : arr){e++;}cout << endl;for (auto e : arr){cout << " " << e;}cout << endl;}void printf_(int arr[]) for(auto e:arr)//error 数组传参的时候会退化为指针，不再是数组名字{cout<<e<<endl;}
}

nullptr

c++中用nullptr中比null好

void f(int)
{cout << "f(int)" << endl;
}
void f(int *)
{cout << "f(int *)" << endl;
}
int main()
{f(NULL);// NULL = 0 调用了f(int),本意是调用f(int*)f(nullptr);//调用f(int *)
}