个人主页 ： 个人主页
文章目录
前言
本篇博客作为C++知识总结，我们来认识命名空间，缺省参数，函数重载，引用，内联函数。
一、命名空间
那么在介绍命名空间时，我们先用C++的方式打印"hello world"。
cpp
#include <iostream>
using namespace std;
int main()
{
cout << "hello world" << endl;
return 0;
}其中，using namespace std; 就是一种命名空间的使用。
在C++中，变量，函数和后面要学习到的类都是大量存在的，这些变量，函数，类的名称都存在全局作用域中，可能会造成命名冲突，使用，命名空间的目的是对标识符的名称进行本地化，以避免命名冲突或命名污染，namespace关键词的出现就是针对这种问题。
比如：在C时，我们定义变量time时，有包含了头文件<time.h>，这就会造成命名冲突。但在C++，我们可以将变量time定义在一个命名空间内从而避免这一情况发生。
这会使编译器发出 error C2063: "time": 不是一个函数的警告。
命名空间的定义
定义命名空间，需要使用namespace关键词，后面跟命名空间的名字，然后接一对{}即可，{}中即为命名空间的成员。
命名空间中可以定义变量，函数，类型
cpp
namespace test
{
//变量
int time = 0;
//函数
int Add(int left, int right)
{
return left + right;
}
//类型
struct Stu
{
char name[20];
char sex[5];
int age;
};
}命名空间可以嵌套定义
cpp
namespace test
{
int time = 0;
int Add(int left, int right)
{
return left + right;
}
struct Stu
{
char name[20];
char sex[5];
int age;
};
//嵌套定义test1命名空间
namespace test1
{
int time1 = 1;
int sub(int a, int b)
{
return a - b;
}
}
}一个工程中允许定义多个相同的命名空间，编译器会将多个相同的命名空间合并为一个
命名空间的使用
- 命名空间名称及作用域限定词( :: )
c
#include <iostream>
using namespace std;
namespace test
{
int time = 0;
int Add(int left, int right)
{
return left + right;
}
struct Stu
{
char name[20];
char sex[5];
int age;
};
}
int main()
{
cout << test::time << endl;
cout << test::Add(1, 2) << endl;
struct test::Stu s;
return 0;
}- 使用using将命名空间中某个成员引入(部分引入)
cpp
#include <iostream>
using namespace std;
namespace test
{
int time = 0;
int a = 10;
int Add(int left, int right)
{
return left + right;
}
struct Stu
{
char name[20];
char sex[5];
int age;
};
}
using test::Add;
using test::a;
int main()
{
//此处time是函数名，表示函数的地址
//不能using test :: time 会造成冲突，time变量只能test::time访问
cout << time << endl;
cout << a << endl;
cout << Add(1, 2) << endl;
struct test::Stu s;
return 0;
}- 使用using namespace 命名空间名称 引入
cpp
#include <iostream>
using namespace std;
namespace test
{
//全部引入时，time变量与time函数会冲突
//int time = 0;
int a = 10;
int Add(int left, int right)
{
return left + right;
}
struct Stu
{
char name[20];
char sex[5];
int age;
};
}
using namespace test;
int main()
{
cout << a << endl;
cout << Add(1, 2) << endl;
return 0;
}二、缺省参数
缺省参数概念
缺省参数是声明或定义函数时为函数的参数指定一个缺省值(默认值)，在调用该函数时，如果没有指定实参则采用该形参的缺省值。
- 缺省参数不能同时出现在定义与声明中
- 缺省值必须是常量或者全局变量
如下展示：函数func的参数a就是缺省参数。
cpp
#include <iostream>
using namespace std;
void func(int a = 10)
{
cout << a << endl;
}
int main()
{
func();
func(1);
return 0;
}结果如下：
缺省参数分类
- 全缺省参数
cpp
#include <iostream>
using namespace std;
void func(int a = 10, int b = 20, int c = 30)
{
cout << a << endl;
cout << b << endl;
cout << c << endl;
}
int main()
{
func();
cout << endl;
func(1);
cout << endl;
func(1, 2);
cout << endl;
return 0;
}结果如下：
-
半缺省参数
-
半缺省参数必须从右往左依次来给，不能间隔的给
cpp
#include <iostream>
using namespace std;
void func(int a, int b = 1, int c = 2)
{
cout << a << endl;
cout << b << endl;
cout << c << endl;
}
int main()
{
func(0);
cout << endl;
func(0, 10);
cout << endl;
func(0,10,20);
cout << endl;
return 0;
}
三、函数重载
函数重载的概念
函数重载 ：是函数的一种特殊情况，C++允许在同一作用域中声明几个功能类似的同名函数 ，这些同名函数的形参列表(参数个数，类型，类型顺序)不同，常用来处理实现功能类似数据类型不同的问题。
- 如果两个同名函数只有返回值不同，并不能构成函数重载
参数类型不同
cpp
#include <iostream>
using namespace std;
int Add(int a, int b)
{
return a + b;
}
double Add(double a, double b)
{
return a + b;
}
int main()
{
cout << Add(1, 2) << endl;
cout << Add(1.1, 2.2) << endl;
return 0;
}
参数个数不同
cpp
#include <iostream>
using namespace std;
void func()
{
cout << "void func()" << endl;
}
void func(int i, int j)
{
cout << "void func(int i, int j)" << endl;
}
//注意无参函数的重载函数，不能有全缺省类型的函数，会造成函数调用的二义性
//void func(int i = 1, int j = 1, int k = 1)
//{
// cout << "void func(int i = 1, int j = 1, int k = 1)" << endl;
//}
int main()
{
func();
func(1, 1);
return 0;
}
参数类型顺序不同
cpp
#include <iostream>
using namespace std;
void func(int i, double j)
{
cout << "void func(int i, double j)" << endl;
}
void func(double i, int j)
{
cout << "void func(double i, int j)" << endl;
}
int main()
{
func(1, 1.1);
func(1.1, 1);
return 0;
}
四、引用
引用的概念
引用并不是新定义的变量，而是给已有变量取了一个别名(类似于给人取一个外号)，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块空间。
类型 + & + 引用对象名 = 引用实体
cpp
#include <iostream>
using namespace std;
int main()
{
int i = 0;
//定义引用类型
// 类型 & 对象名 引用实体
int & ri = i;
cout << &i << endl;
cout << &ri << endl;
return 0;
}
引用特性
- 引用在定义时必须初始化
- 一个变量可以有多个引用
- 引用一旦引用一个实体，就不能再引用其它实体
- 引用的权限可以平移，缩小，不能放大
引用在定义时必须初始化
一个变量可以有多个引用
cpp
#include <iostream>
using namespace std;
int main()
{
int i = 0;
int& ri = i;
int& rri = i;
int& rrri = i;
cout << &i << endl;
cout << &ri << endl;
cout << &rri << endl;
return 0;
}
引用一旦引用一个实体，就不能再引用其它实体
引用的权限可以平移，缩小，不能放大
引用的使用场景
1.做参数
引用做返回值 与 指针作用类似，都可以通过形参直接改变实参，但引用使用更舒服。
c
#include <iostream>
using namespace std;
void swap(int& i, int& j)
{
int tmp = i;
i = j;
j = tmp;
}
int main()
{
int i = 0;
int j = 10;
cout << " i = " << i << " j = " << j << endl;
swap(i, j);
cout << " i = " << i << " j = " << j << endl;
return 0;
}
2.做返回值
- 如果函数返回时，出了函数作用域，如果返回对象存在，则可以使用引用返回，如果已经返回系统了，则必须使用传值返回。
如下：(1) , (2) , (3)的结果是什么？
cpp
int& Add(int a, int b)
{
int c = a + b;
return c;
}
int main()
{
int& ret = Add(1, 2);
cout << "Add(1,2) = " << ret << endl;// (1)
Add(3, 4);
cout << "Add(1,2) = " << ret << endl;// (2)
cout << "Add(1,2) = " << ret << endl;// (3)
return 0;
}
为什么是这个结果？ret不是只接受了一次函数函数返回值吗？
这就是因为变量c的生命周期是随着函数栈帧的创建而创建，栈帧的销毁而销毁(栈帧的销毁并不会真的销毁空间，C变量空间的值并不会改变，只是esp 与 ebp的指向变了)。《函数栈帧的创建与销毁》
ret也是指向变量C的空间，第一次打印ret的值，变量C空间的值不变，可以打印出3。当第二次调用Add(3, 4)函数时，main函数栈帧上并未有其它栈帧存在，此时Add(3,4)的栈帧位置与Add(1,2)的栈帧位置相同，那么ret指向变量C的空间就被这次变量C的空间覆盖，变量空间的值就变成7。当第二次打印ret的值时，ret的值就是7，此时cout << "Add(1,2) = " << ret << endl;也是一个函数调用，会覆盖变量C的空间，使变量C的空间变成随机值，所以第三次打印ret的值就是随机值。
引用与指针的区别
在语法概念上引用就是一个别名，没有独立空间。但在底层实现上，引用实际是有空间的，因为引用就是按照指针方式来实现的。
cpp
#include <iostream>
using namespace std;
int main()
{
int i = 0;
int& ri = i;
int* pi = &i;
return 0;
}
可以看到在底层实现方面，引用与指针并无不同。
那引用与指针有区别吗？
- 引用概念上定义一个变量的别名，指针存储一个变量的地址。
- 引用在定义时必须初始化，指针没有要求
- 引用在初始化时引用一个实体后，就不能再引用其它实体，而指针可以在任何时候指向任何一个同类型实体
- 没有NULL引用，但有NULL指针(在C++中是nullptr)
- 在sizeof中含义不同：引用结果为引用类型大小，指针始终是地址空间所占字节数(4 / 8)
- 引用的值改变即引用的实体本身的值改变，指针的值改变则指向了不同的变量
- 有多级指针，没有多级引用
- 访问实体方式不同，指针需要显示解引用，引用编译器会自己处理
- 引用比指针更安全
五、内联函数
在C语言中，有时我们要提高程序效率，会将一些简单的函数写成宏的形式，来提供程序效率。但对于宏函数而言，它出错时并不好调试检查。于是C++对与这一情况提出来内联函数的概念。
以inline 修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开，没有函数调用创建栈帧的开销，内联函数就可以代替宏函数。
如下：Add函数被inline修饰后，在调用时就没有call指令，而是直接进行相加。
cpp
#include <iostream>
using namespace std;
inline int Add(int a, int b)
{
return a + b;
}
int main()
{
int ret = 0;
ret = Add(1, 2);
return 0;
}
特性
- inline是一种以空间换时间的做法，如果编译器将函数当成内联函数处理，在编译阶段，会用函数体替换函数调用，缺陷：可能使目标文件变大
- inline对于编译器而言只是一个建议，不同编译器关于inline实现机制不同，一般建议：将函数规模较小，不是递归，且频繁调用的函数用inline修饰，否则编译器有可能会忽视inline的特性
- inline不建议声明和定义分离，分离会导致链接错误，因为inline被展开，就没有函数地址了，在链接阶段，编译器依据符号表就找不到函数地址。
总结
以上就是我对于C++中命名空间，缺省参数，函数重载，引用，内联函数的总结。感谢支持！！！
