c++基础篇

一、命名空间：

1.1命名空间存在的意义：

1.1要知道c++是对c语言缺点的完善，而在c语言中我们是知道，定义变量、函数名或者全域名是不能相同的，否则会产生冲突，但要知道这都是大量存在的，就像一个名字也有很多重名，一个项目，每个人负责不同的模块，也避免不了名字相同（因为我不知道你也用了这个名字），在c语言中就会产生冲突，而且在全域中也可能和库函数中名字相同例如：

1.2命名空间的定义：

 1.2.1命名空间的定义要用到一个关键字就是namespace加命名空间的名字，然后接一个{ },里面就是命名空间的成员。

//这我定义一个名字为xiaoming
namespace xiaoming
{//可以定义变量也可以定义函数int rand = 10;int add(int x, int y){return x + y;}// 同时可以进行嵌套namespace hello // 嵌套在命名空间xiaoming的命名空间hello// 不同命名空间里的名字可以相同{int rand = 20;int add(int x, int y){return x + y;}}
}

1.3命名空间的使用：

1.3.1命名空间中的成员并不能直接使用，有三种形式使用方式：

<1>加命名空间名称以及作用域符号：：

# include <iostream>
using namespace std;namespace xiaoming
{int a = 10;int b = 20;
}int main()
{// cout << a << 这种是错误的不能直接使用cout << xiaoming::a;cout << xiaoming::b;
}

<2>使用using将命名空间某个成员引入：

# include <iostream>
using namespace std;
using xiaoming::a;namespace xiaoming
{int a = 10;int b = 20;
}int main()
{cout << a; //这个已经被引入所以可以直接使用cout << xiaoming::b;
}

<3>使用using namespace命名空间的引入

# include <iostream>
using namespace std;
using namespace xiaoming;namespace xiaoming
{int a = 10;int b = 20;
}int main()
{cout << a;cout << b;
}

二、缺省参数：

3.1缺省参数的定义：

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

#include<iostream>
using namespace std;
int Add(int x=10,int y=20)
{return x+y;
}
int main()
{int ret1=Add();  //不穿参数，使用形参默认值cout<<ret1<<endl;int ret2=Add(1,2)  //穿参数，使用指定实参cout<<ret2<<endl;return 0;
}

3.2省参数的分类：

全缺省参数：

#include<iostream>
using namespace std;
int Add(int x=10,int y=20,int z=30)
{return x+y+z;
}
int main()
{int ret1=Add(); //可以不传参数int ret2=Add(1); //可以传一个参数int ret3=Add(1,2); //可以传两个参数int ret4=Add(1,2,3); //可以传三个参数//但不能像Add(,2,3)或者这样Add(1,,3)传参，必须是从左到右连续滴传参。cout<<ret1<<endl<<ret2<<endl<<ret3<<endl<<ret4<<endl;

半省参数：

#include<iostream>
using namespace std;
int Add(int x,int y=20,int z=30)
{return x+y+z;
}//半省参数必须从右向左依次赋值
int Add1(int x,int y,int z=30)
{return x+y+z;
}
//上面两种都是可以的
//但不能中间间隔例如：int Add(int x=10,int y,int z=30)
//或者这样也是不行的 int Add(int x=10,int y,int z)
int main()
{int ret1=Add(1,2,3);//可以int ret2=Add(1,2);//可以int ret3=Add(1);//可以// int ret4=Add(); 不可以的x需要传参
同样滴int ret5 =Add1(1,2,3);//可以int ret6=Add(1,2);//可以//  int ret7=Add(1); 不可以因为y没有传参//半缺省参数是要赋值的return 0;
}

函数重载：

函数重载的概念：

C++允许在同一作用域中声明几个功能类似的同名函数，这些同名函数的形参列表（参数个数或类型或类型顺序）不同，常用来处理实现功能类似数据类型不同的问题。

#include<iostream>
using namespace std;
int Add(int x,int y,int z)
{return x+y+z;
}
//参数个数不同
int Add(int x,int y)
{return x+y;
}
//参数类型不同
double  Add(double x,double y)
{return x+y;
}
//参数顺序不同
double  Add(int x,double y)
{return x+y;
}
double  Add(double y, int x)
{return x+y;
}
int main()
{int  ret =Add(1,2,3);int  ret1=Add(1,2);double   ret2=Add(1.2,2.2);double   ret3=Add(1,1.2);double   ret4=Add(1.2,1);  //函数重载的作用就是一个函数可以实行多种功能cout<<ret<<endl<<ret1<<endl<<ret2<<endl<<ret3<<endl<<ret4<<endl;return 0;
}

编译器的工作：
  如果两个函数的参数表中参数的个数或类型或顺序不同，则认为这两个函数是重载。

判断函数重载的规则

如果两个函数的参数表相同， 但是返回类型不同，会被标记为编译错误：函数的重复声明

int my_max(int a,int b)
{return a > b ? a : b;
}
unsigned int my_max(int a,int b) // error;
{return a > b ? a : b;
}
int main()
{int ix = my_max(12,23);unsigned int = my_max(12,23); // error;reutrn 0;
}

参数表的比较过程与形参名无关

// 声明同一个函数
int my_add(int a,int b);
int my_add(int x,int y);

如果在两个函数的参数表中，只有缺省实参不同，则第二个声明被视为第一个的重复声明

void Print(int *br,int n);
void Print(int *br,int len = 10);

引用：

引用的概念：

引用比较好理解啦，就是给你原有的变量去了一个别名，例如在生活中你的外号，就像叫我小马一样都是别名的意思，编译器不会给引用变量开辟新的内存，他和他引用的变量公用同一个内存空间。

#include<iostream>
using namespace std;
int main()
{int a=10;int& ra=a;printf("%p\n",&a);  //打印a的地址printf("%p\n",&ra);    //打印ra的地址 两个地址是相同的 return 0;

引用的特性：

<1>引用变量必须初始化。 就像你给一个人起小名要有对象呀

<2>一个变量可以有多个引用。  一个人可以有多个外号什么的

<3>引用一旦引用一个实体，再也不能引用其他实体。

#include<iostream>
using namespace std;
int main()
{int a=10;int&ra=a; //这是引用的初始化// int&ra; //这里没有初始化是不正确的。int& rb=a; //一个变量可以有多个引用return 0;
}

引用的应用：

引用做参数：

通过引用的概念我们可以知道引用是和他的引用变量用同一个地址，所以改变引用就是改变他所引用的变量，就像夸小马文章写的好不就是在夸我吗

#include<iostream>
using namespace std;
void swap(int& x,int& y)
{int tmp=0;tmp=x;x=y;y=tmp;
}
int main()
{int x=10;int y=20;swap(x,y);cout<<x<<' '<<y<<endl;return 0;
}

引用做返回值：

#include<iostream>
using namespace std;
int& Add(int x,int y)
{static int ret=x+y; //想想这里为什么用staticreturn ret;
}
int main()
{int ret=Add(1,2);cout<<ret<<endl;return 0;
}

在这里我们想一下为什么要用static 要是不用static的后果是什么呢？ 在我们讲函数栈帧的创建和销毁的时候已经知道，局部变量是储存在栈区的，而栈区是随着函数调用结束后是会被销毁的， 但引用是和引用对象一个地址的，static是把局部变量从栈区存放到静态区，这样随着函数的调用结束后不会被销毁，因此返回的时候还能够找到，要是不用static当返回去寻找的时候是找到的就会是随机值。就好比你住个酒店，而当你退房了之后，发现你的包裹没有拿，而当你返回去的时候，你就无法确定你的包裹还在，他可能还在就是没有被收拾，但有可能你住的酒店已经被其他用户住给扔掉了，这都是有可能的，而static就是把包放在一个储存的东西的地方，你再去这个地方拿就行了

引用和指针的区别：

引用就是引用对象的一个别名，而指针是变量的地址

引用必须初始化，而地址不需要初始化。

引用在初始化一个引用对象后就不能在引用其他变量了，而指针确可以在任何时候指向同类型的地址。

用自身加一是引用对象加一，而指针加一则是地址加一。

指针有多级指针，而引用没有

内联函数：

内敛函数存在的意义：

 在c语言中调用一个函数要经过栈帧的创建和销毁，而当一个函数调用次数过多的时候就会降低程序运行的效率。这里的解决办法是什么呢？在c语言中有一个解决的方法就是宏函数。想必大家也忘了宏函数的写法了，这里我写一个宏函数的代码。

#include<iostream>
using namespace std;
#define Add(x,y)   ((x)+(y))
int main()
{int ret=Add(1,2);cout<<ret<<endl;return 0;
}

为什么宏函数解决了效率呢，要知道一个程序运行的完整运行，是有预处理，编译，汇编，链接四个过程的，而宏函数是在预处理已经完成了。但宏函数已经解决了c栈帧创建和销毁的缺点，为什c++还会创建一个内敛函数呢？要知道虽然宏函数解决了效率问题，但它本身也有自身的缺点，我们可以看出宏函数还是很容易写错的，我这个是比较简单的，要是复杂一点就是很容易就写错的，而宏函数因为在预处理就已经结束了，所以是没有办法调试的，并且他也没有类型安全的检查，因此c++就用内敛函数来解决这个问题。

内敛函数的定义：

以inline修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开，没有函数调 用建立栈帧的开销，内联函数提升程序运行的效率。

#include<iostream>
using namespace std;
inline int Add(int x,int y)
{return x+y;
}
int main()
{int ret =Add(1,2);cout<<ret<<endl;return 0;
}

内敛函数和普通函数功能相同就是在函数inline同时也具有了宏函数的一些功能就是不参与编译，在预处理就已经完成了。

内敛函数特性:

inline是一种以空间换时间的做法，如果编译器将函数当成内联函数处理，在编译阶段，会用函数体替换函数调用，缺陷：可能会使目标文件变大，优势：少了调用开销，提高程序运行效率。

inline对于编译器而言只是一个建议，不同编译器关于inline实现机制可能不同，一般建议：将函数规模较小(即函数不是很长，具体没有准确的说法，取决于编译器内部实现)、不是递归、且频繁调用的函数采用inline修饰，否则编译器会忽略inline特性。