命名空间
在C/C++ 中，变量、函数和类是大量存在的，这些变量、函数和类的名称都存在于全局作用域中，可能会导致很多冲突。使用命名空间的目的是对标识符的名称进行本地化，以避免命名冲突或名字污染。（同一个域中，不能定义同名变量；但不同域，可以）
当全局域和局部域存在同名变量时，默认实在局部搜索，可以使用域作用限定符：：来搜索。
int a = 0;//全局域
int main()
{
int a = 1;//局部域
printf("%d\n", a);//打印局部域a
printf("%d\n", ::a);//打印全局域a
// :: 域作用限定符（左边俩冒号前边有一个空格，代表去全局域访问）
}
当在多个域中存在同名变量，访问顺序为：局部与>全局域>展开了的命名空间域or指定访问命名空间域（如果不指定时不会主动去命名空间搜索）
int a = 0;
namespace bit
{
int a = 1;
}
using namespace bit;//展开命名空间
int main()
{
int a = 2;
printf("%d\n", a);
return 0;
}
命名空间可以不用全部展开，只展开常用的
using std::cout;
using std::end;
命名空间的定义
定义命名空间需要使用关键字——namespace ，后面跟命名空间的名字，然后接一对{}，{}中为命名空间的成员
namespace N1//N1为命名空间的名称
{
//命名空间中的成员可以是变量也可以是函数
int a;
int Add(int num1, int num2)
{
return num1 + num2;
}
}//这个位置不能给分号
namespace N2//命名空间可以嵌套
{
int a;
int b;
int Add(int num1, int num2)
{
return num1 + num2;
}
namespace N3
{
int c;
int d;
int Sub(int num1, int num2)
{
return num1 - num2;
}
}
}
namespace N1//同一工程中允许存在多个相同名称的命名空间，编译器最后会合并成同样一个一个命名空间
{
int Mul(int num1, int num2)
{
return num1 * num2;
}
}
一个命名空间就定义了一个新的作用域，命名空间中的所有内容都局限于该命名空间中。
命名空间的使用
- 加命名空间名称及作用域限定符
namespace N
{
int a = 10;
int b = 20;
int Add(int num1, int num2)
{
return num1 + num2;
}
int Sub(int num1, int num2)
{
return num1 - num2;
}
}
- 使用using将命名空间中成员引入
namespace N
{
int a = 10;
int b = 20;
int Add(int num1, int num2)
{
return num1 + num2;
}
int Sub(int num1, int num2)
{
return num1 - num2;
}
}
using N::b;
int main()
{
printf("%d\n", b);
return 0;
}
- 使用using namespace命名空间名称 引入
namespace N
{
int a = 10;
int b = 20;
int Add(int num1, int num2)
{
return num1 + num2;
}
int Sub(int num1, int num2)
{
return num1 - num2;
}
}
using namespace N;
int main()
{
printf("%d\n", b);
return 0;
}
-std 为标准库的命名空间
- 项目中，尽量不要用using namespace std；
- 日常练习用using namespace std;
- 项目中，指定名空间访问+正常使用
C++的输入和输出
- 使用cout标准输出和cin标准输入时，必须包含头文件以及std标准命名空间
- 早期标准库将所有功能在全局域中实现，声明在.h后缀的头文件中，使用时只需包含对应头文件即可，后来将其是现在std命名空间下。为了和C头文件区分，也为了正确使用命名空间，规定C++头文件不带.h
- 使用C++的输入输出，不需要增加数据格式控制
int main()
{
int i;
double d;
// >>流提取
cin >> i >> d;
// <<流插入
cout << i << endl;
cout << d << endl;
cout << "hello world" << endl;
return 0;
}
缺省参数
缺省参数是声明或定义函数时，为函数的参数指定一个默认值。在调用该函数的时候，如果没有指定实参，则采用该默认值，否则使用指定实参。
void Func(int a = 100)
{
cout<<a<<endl;
}
int main()
{
Func();//打印“100”
Func(10);//打印“10”
return 0;
}
void Func(int a = 10, int b = 100, int c = 1000)
{
cout << "a = " << a << endl;
cout << "b = " << b << endl;
cout << "c = " << c << endl;
}
int main()
{
Func();//打印“a = 10” "b = 100" "c = 1000"
Func(1);//打印“a = 1” "b = 100" "c = 1000"
Func(1, 2)://打印“a =1 ” "b = 2" "c = 1000"
Func(1, 2, 3);//打印“a =1 ” "b = 2" "c =3 "
//Func(1, , 3);//这样不行
}
- 缺省参数又分为全缺省参数和半缺省参数
- 半缺省参数必须从右往左依次给出，不能出现间隔
- 半缺省参数不能在函数声明和定义中出现
- 缺省值必须是常量或者全局变量
- C语言不支持（编译器不支持）
全缺省参数
void Func(int a = 10, int b = 100, int c = 1000)
{
cout << "a = " << a << endl;
cout << "b = " << b << endl;
cout << "c = " << c << endl;
}
半缺省参数
void Func(int a, int b = 100, int c = 1000)
{
cout << "a = " << a << endl;
cout << "b = " << b << endl;
cout << "c = " << c << endl;
}
函数重载
函数重载是函数的一种特殊情况，C++允许在同一作用域中声明几个功能类似的同名函数，这些同名函数的形参列表（参数个数 或 类型 或 顺序）必须不同。(返回值没有要求）
//参数类型不同
int Add(int num1, int num2)
{
return num1 + num2;
}
double Add(double num1, double num2)
{
return num1 + num2;
}
int main()
{
Add(1, 2);
Add(1.0, 2.0);
return 0;
}
c/c++编译链接过程：
- 预处理：头文件展开、宏替换、条件编译、去除注释… ——file.i
- 编译：检查语，生成汇编代码——file.s
- 汇编：汇编代码转换为二进制机器码——file.o
- 链接：生成可执行程序——file.exe（Linux下为a.out或其他）
引用
引用概念
引用不是新定义一个变量，而是给已存在的变量取一个别名。编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。
类型&引用变量名（对象名）= 引用实体
引用类型必须和引用实体是同种类型的
引用做输出型参数——提高效率（大对象、深拷贝类对象）
void Swap(int &left, int &right)
{
int temp = left;
left = right;
right = temp;
}
引用做返回值 ——减少拷贝提高效率
+
int &Count()
{
static int n = 0;
n++;
return n;
}
int main()
{
int ret = Count();//这里n是做ret的返回值
return 0;
}
//这里ret的值是不确定的
//如果Count函数结束，栈帧销毁，没有清理栈帧，那么ret的结果侥幸是正确的
//如果Count函数结束，栈帧销毁，清理栈帧，那么ret的结果是随机值
int &Count()
{
static int n = 0;
n++;
return n;
}
int main()
{
int &ret = Count();//这里ret是n的别名
return 0;
}
引用特性
- 引用在定义时必须初始化
- 一个变量可以有多个引用
- 一旦引用一个实体，便不能引用其他实体
//一个变量可以有多个引用
int a = 0;
int& b = a;
int& c = b;
//int &d;引用在定义时必须初始化
//引用一旦引用一个实体，再不能引用其他实体
int x = 10;
c = x;//x的值给c，c依旧是a/b对象别名
常引用
int main()
{
//权限放大
//const int c = 20;
//int& d = c;//引用过程中，权限不能放大
//权限平移
const int c = 20;
const int& d = c;
//权限缩小
int e = 30;
const int& f = e;
//权限不可以放大，但是可以缩小。
int g = 1;
double h = g;//显示类型转换
//double& i = g; //这样写编译不通过
const double& i = g;
//类型转换会产生临时变量
// g -->临时变量 -->i
// i引用的是临时变量，而不是
// 临时变量具有常性（就像被const修饰了一样）
//强制类型转换并不会改变变量类型,中间都会产生一个临时变量
const int& x = 10;//C++也支持直接引用常量
}
int func1()
{
static int x = 0;
return x;//这里func1返回的不是x，而是一个临时变量。而临时变量具有常性
}
int func2()
{
static int x = 0;
return x;//这里没有产生临时变量，而是返回x的别名
}
int main()
{
//int &ret1 = func1();这样不可以，因为权限放大了
const int &ret1 = func1();//这样可以,权限平移
int &ret2 = func2();//权限平移
const int &ret2 = func2();//权限缩小
return 0;
}
权限的放大和缩小只针对引用和指针
void func1(int n) {}
void func2(int& n) {}
void func3(const int& n) {}
int main()
{
int a = 10;
const int b = 20;
func1(a);
func1(b);//n只是b的临时拷贝，所以不影响b只读不写的特性
func1(30);
func2(a);
//func2(b);//n是b的别名；b是只读不写，而n是可读可写；这里是权限的放大
//func2(30);
//所以如果使用引用传参，函数内如果不改变n，那么建议尽量使用 const引用 传参
func3(a);
func3(b);
func3(30);
double c = 3.33;
func3(c);//这样子会报警，但依旧可以编译通过；所以 const引用 具有很高的兼收度
return 0;
}
使用场景
1. 做参数——输出型参数、大对象传参，提高效率
void Swap(int& left, int& right)
{
int temp = left;
left = right;
right = temp;
}
int main()
{
int a = 10;
int b = 20;
Swap(a, b);
cout << a << endl;
cout << b << endl;
}
2. 做返回值
函数返回时，出了函数作用域，如果返回对象还未被销毁，则可以用传引用返回；如果已经销毁，则必须要用传值返回。
int &Count()
{
static int n = 0;
n++;
return n;//返回 返回对象的别名
}
int main()
{
int ret = Count();
return 0;
}
传值与传引用效率比较
以值作为参数或者返回值类型，在传参和返回期间，函数不会直接传递实参或者将变量本身直接返回，而是传递实参或者返回变量的一份临时拷贝，因此用值作为参数或者返回值类型，效率非常低，尤其是当参数或者返回值类型非常大时。
值和引用作为参数的比较
值和参数作为返回值的比较
引用和指针的区别
在语法概念上引用就是一个别名，没有独立空间，和其引用实体公用同一块空间 在底层实现上实际是有空间的，因为引用是按照指针方式实现的
- 引用与指针的不同：
- 引用在定义时必须初始化，而指针没有要求
- 引用在初始化时引用一个实体后，就不能在引用其他实体；而指针可以在任何时候指向任何一个同类型实体。
- 没有NULL引用，但有NULL指针
- 在sizeof中含义不同，引用为引用类型大小；指针为地址空间所占字节个数
- 没有多级引用，但有多级指针
- 引用自加表示所引用实体加1；指针自加表示指针向后偏移一个类型的大小
- 访问实体，指针需要显式解引用；引用 编译器会自己处理
总的来说：指针更强大、更危险、更复杂；引用相对局限一点，但是更安全、更简单。
auto
int main()
{
int a = 0;
int b = a;
auto c = a;//根据右边的表达式自动推导c的类型
auto d = 1 + 1.11;//根据右边的表达式自动推导d的类型
}
用auto声明指针类型时，用auto或auto*没有区别；但是用auto声明引用类型时，必须加&
在同一行定义多个变量时，这些变量得是相同类型（编译器实际只对第一个类型进行推导，然后用推导出来的类型定义其他变量）
auto a = 0, b = 1;
//auto c = 2, d = 2.1;//这样不行，因为c、d的表达式类型不同
范围for
int main()
{
int arr[] = {1, 2, 3, 4, 5};
for (int i = 0; i < sizeof(arr) / sizeof(int); ++i)
{
arr[i] *= 2;
}
for (int *p = arr; p < arr + sizeof(arr) / sizeof(arr[0]); ++p)
{
cout << *p << endl;
}
//范围for语法（适用于数组）
//依次取数组中数据赋值给e
//自动迭代，自动判断结束
for (auto x : arr)//这里auto改为int也可以//for(int x : arr)
{
cout << x << " ";
}
cout << endl;
}
修改数据
for (auto &e : arr)
{
e *= 2;//这里e的改变不会改变数组中的内容
}
宏函数
//int Add(int x, int y)
//{
// return (x + y) ;
//}
#define Add(x, y) ((x) + (y))
//宏是一种替换,不需要类型//#define Add(int x, int y) (（x） + （y）)这样不行
int main()
{
int a = 1, b = 2;
Add(a | b, a & b);
//#define Add(x, y) (x + y)也不行
//宏函数的本质是替换，这样替换：(a | b + a & b),加号的优先级比较高，不符合我们的预期
}
宏函数
优点：不需要建立栈帧，提高调用效率
缺点：复杂，容易出错，可读性差，没法调试
内联函数
//普通函数前加inline
inline int Add(int x, int y)
{
return (x + y);
}
//内联函数不需要建立栈帧，不复杂1、不容易出错、可读性不差、可以调试
内联函数与宏函数一般，适用于短小且频繁调用的函数
inline对于编译器仅仅是个建议。
默认debug模式下，inline不会起作用，需要对编译器进行设置
6378
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
