C++入门基础认知--命名空间、输入&输出、缺省参数、函数重载、引用、内联函数

最新推荐文章于 2024-05-21 09:15:43 发布

小小分享君

最新推荐文章于 2024-05-21 09:15:43 发布

阅读量858

点赞数 34

文章标签：开发语言 c++ 学习

本文链接：https://blog.csdn.net/2301_77637225/article/details/136521095

版权

C++入门基础认知--命名空间、输入&输出、缺省参数、函数重载、引用、内联函数

1. 命名空间
1.1 命名空间的提出
- 1.2 命名空间的定义
1.3 命名空间的使用
2. 输入&输出
3. 缺省参数
- 3.1 缺省参数的概念
- 3.2 缺省参数的分类
4. 函数重载
4.1 函数重载的概念
4.2 函数重载的分类
5. 引用
5.1 引用的概念
5.2 引用的特性
5.3 常引用
5.4 引用的使用场景
6. 内联函数
6.1 内联函数概念
6.2 内联函数的特性
总结

C++是一种通用编程语言，被广泛应用于系统软件开发、游戏开发、嵌入式系统、高性能计算等领域。它是C语言的扩展，具有更强大的功能和更丰富的特性，包括面向对象编程、模板、异常处理等。

C++在编程领域中的地位非常重要，它是一种被广泛应用的编程语言，许多大型软件项目和系统都是用C++编写的。由于其高效性和灵活性，C++在许多领域都有着重要的地位。

本文将对C++的命名空间、输入&输出、缺省参数、函数重载、引用、内联函数六个基本概念进行讲解

1. 命名空间

在C++代码的编写过程中，在开头一般都会有这么一行代码：

using namespace std;

这行代码的意思是直接展开标准库命名空间，具体含义参见下文。

1.1 命名空间的提出

C++被誉为C语言的进阶版，相比起C语言而言，C++增添了很多库函数与关键字，很多在C语言里面需要我们亲自动手实现的函数都被封装成了库函数。因此在编写自己的函数的时候很有可能与库函数名冲突。此外，在和别人一起编写大型程序的时候，相互之间是的函数命名也很有可能冲突，如此一来就无法很好的做到代码的兼容性。

为了解决这个问题，C++提出了命名空间的概念，即将不同人写的函数放在各自划定的区域中保护起来，需要访问该域函数的时候通过将该函数从自己的域中展开，使程序能够进行访问，避免了相互之间的命名干扰。

1.2 命名空间的定义

定义命名空间，需要使用到namespace关键字，后面跟命名空间的名字，然后接一对{}即可，{}中即为命名空间的成员。

命名空间中可以放变量、函数、自定义类型等，只要是符合语法，基本都可以放在里面。此外，命名空间还可以嵌套使用。

namespace MySpace//MySpace 是这个命名空间的名字，根据实际情况自己取定
{
	int rand = 0;
	//变量rand 的名字与库函数rand（） 重复
	//在命名空间中可以存在，但不可以直接在命名空间之外使用
	void swap(int a, int b)//C++库函数中已经有swap库函数，在命名空间外会重载，不能这样命名
	{
		int tmp = a;
		a = b;
		b = tmp;
	}
	struct Node
	{
		struct Node* next;
		int val;
	};
}

命名空间的嵌套使用：

// test.cpp
namespace name1
{
	 int a;
	 int Add(int left, int right)
	 {
    	 return left + right;
	 }
 namespace name2
 {
	  int b;
   	  int Sub(int left, int right)
   	  {
   	     return left - right;
      }
 }
}

同一个工程中允许存在多个相同名称的命名空间,编译器最后会将相同名称的命名空间合成同一个命名空间

1.3 命名空间的使用

命名空间的作用域限定符为两个并列的冒号，不可将其分开，如下方代码所示。

命名空间的使用有三种方式：

1. 加命名空间名称及作用域限定符

2. 使用using将命名空间中某个成员引入

3. 使用using namespace 命名空间名称引
入
以以下的代码为例:

namespace name
{
	 int a = 3;
	 int d = 6;
	 int Add(int left, int right)
	 {
    	 return left + right;
	 }
}

1. 加命名空间名称及作用域限定符

int main()
{
    printf("%d\n", name::a);
    //此处指定了具体的命名空间
    //需要寻找a的值时，会到name空间中去寻找
    return 0;    
}

2. 使用using将命名空间中某个成员引入

using name::b;//此处将变量 b 从name这个命名空间中展开，使得可以在全局使用变量b
int main()
{
    printf("%d\n", N::a);//见上面注释
    printf("%d\n", b);//没有using name::b时，此处无法打印b 的值
    return 0;    
}

3. 使用using namespace 命名空间名称引
入

using namespce name;
//此处直接将整个命名空间里面的内容展开
//相当于没有命名空间的保护，使得里面的内容直接暴露在全局中
//此时命名重复问题会很严重
int main()
{
    printf("%d\n", name::a);
    printf("%d\n", b);
    Add(10, 20);
    return 0;    
}

在实际的使用当中最常用的是使用方法二：using将命名空间中某个成员引入，即只需要将常用的内容暴露出来即可。

方法一 需要在每个使用命名空间中的内容前面都将是命名空间名称以及命名空间限定符，最安全，但是使用不方便。

方法三 using namespace std展开，标准库就全部暴露出来了，如果我们定义跟库重名的类型/对象/函数，就存在冲突问题。该问题在日常练习中很少出现，但是项目开发中代码较多、规模大，就很容易出现。所以建议在项目开发中使用，像std::cout这样使用时指定命名空间 + using std::cout展开常用的库对象/类型等方式。

当然，以上的优缺点更多的是针对大型项目来说，对于自己的练习代码一般直接展开命名空间即可，这也就是为什么我们在编写代码的时候开头都会加上下面这一行的原因。

using namespace std;//std 是标准命名空间，里面存放了C++的所有库函数

2. 输入&输出

C++的输入关键字为cin,输出关键字为cout,使用如下：

#include <iostream>
using namespace std;
 
int main()
{
   int a;
   double b;
   char c;
     
   // 可以自动识别变量的类型
   cin>>a;//给a变量赋值
   cin>>b>>c;//给b和c变量赋值
     
   cout<<a<<endl;//输出a 变量同时换行
   cout<<b<<" "<<c<<endl;//输出b变量和c变量的值，中间用空格分开
   //双引号里面的内容会被输出，但是双引号自己不会被输出
   return 0;
}

输入a的值为12，b的值为45，c的值为35的输入输出结果如下：
在这里插入图片描述

说明：

使用cout标准输出对象(控制台)和cin标准输入对象(键盘)时，必须包含< iostream >头文件
以及按命名空间使用方法使用std。
cout和cin是全局的流对象，endl是特殊的C++符号，表示换行输出，他们都包含在包含<
iostream >头文件中。
<<是流插入运算符，>>是流提取运算符。
使用C++输入输出更方便，不需要像printf/scanf输入输出时那样，需要手动控制格式。
C++的输入输出可以自动识别变量类型。

3. 缺省参数

3.1 缺省参数的概念

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

void Func(int a = 0)
{
 cout<<a<<endl;
}
int main()
{
 Func();     // 没有传参时，使用参数的默认值
 Func(10);   // 传参时，使用指定的实参
 
 return 0;
}

3.2 缺省参数的分类

1. 全缺省参数：即给所有参数给定一个缺省值

void Func(int a = 10, int b = 20, int c = 30)
 {
     cout<<"a = "<<a<<endl;
     cout<<"b = "<<b<<endl;
     cout<<"c = "<<c<<endl;
 }

2. 半缺省参数：即给一部分参数给定缺省值

void Func(int a, int b = 10, int c = 20)
 {
     cout<<"a = "<<a<<endl;
     cout<<"b = "<<b<<endl;
     cout<<"c = "<<c<<endl;
 }

注意：

半缺省参数必须从右往左依次来给出，不能间隔着给
缺省参数不能在函数声明和定义中同时出现,一般在声明中给定，如果生命与定义位置同时出现，恰巧两个位置提供的值不同，那编译器就无法确定到底该用那个缺省值
缺省值必须是常量或者全局变量
C语言不支持（编译器不支持）

4. 函数重载

4.1 函数重载的概念

在C语言中，为了能够实现仅是参数类型不同的函数，往往采用的是给每个类型的参数写一个函数，例如下面的代码：

int Add_int(int a, int b)
{
	return a + b;
}

double Add_double(double a, double b)
{
	return a + b;
}

不难发现，上面两个函数仅仅只有返回值类型和参数类型不同，但他们实现的内部逻辑是一致的，都是返回他们二者的和。

在C语言中，为了实现int类型和double类型的变量相加，我们不得不专门编写两个不同名称但内核是一致的函数来实现它们各自的相加减，在使用的时候，需要记住每个类型对应下的函数名，增加了使用的成本，为了解决这个问题，C++引入了函数重载的概念

函数重载是函数的一种特殊情况，C++允许在同一作用域中声明几个功能类似的同名函数，这些同名函数的形参列表(参数个数或类型或类型顺序)不同，常用来处理实现功能类似数据类型不同的问题。

4.2 函数重载的分类

函数重载分为三大类：

参数类型不同

int Add(int left, int right)
{
	 return left + right;
}
double Add(double left, double right)
{
	 return left + right;
}

int main()
{
	cout<<Add(2,3)<<endl;//输出6
	cout<<Add(2.5,6.3)<<endl;//输出8.8
	return 0;
}

参数个数不同

void f()
{
 	cout << "f()" << endl;
}
void f(int a)
{
	 cout << "f(int a)" << endl;
}

int main()
{
	f();//输出f()
	f(1);//输出f(int a)
	return 0;
}

参数类型顺序不同

void f(int a, char b)
{
	 cout << "f(int a,char b)" << endl;
}
void f(char b, int a)
{
 	cout << "f(char b, int a)" << endl;
}

int main()
{
	f(1,a);//输出f(int a,char b)
	f(a,1);//输出f(char b，int a)
	return 0;
}

在调用函数的时候，编译器会根据所给参数的类型，自动去调用对应的函数，如此一来，就避免了同一种函数有很多种不同的类型。

5. 引用

5.1 引用的概念

引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空
间，它和它引用的变量共用同一块内存空间。

比如：李白，被称为"诗仙"，又被叫做**“青莲居士”**

引用的使用：

类型& 引用变量名(对象名) = 引用实体；

void TestRef()
{
    int a = 10;
    int& ra = a;//<====定义引用类型
    printf("%p\n", &a);
    printf("%p\n", &ra);
}

注意：引用类型必须和引用实体是同种类型的

void TestRef()
{
    int a = 10;
    char& ra = a;//<====此处引用是错误的
}

5.2 引用的特性

引用在定义时必须初始化
一个变量可以有多个引用
引用一旦引用一个实体，再不能引用其他实体

void TestRef()
{
   int a = 10;
   // int& ra;   // 该条语句编译时会出错
   int& ra = a;
   int& rra = a;
   printf("%p %p %p\n", &a, &ra, &rra);  
}

5.3 常引用

引用变量类型的权限不能够超出被引用对象的权限，例如当引用对象被const 修饰的时候就不能使用直接引用，要在引用变量前面加上const,这是因为被const修饰的对象只有可读权限，不能够被用来赋值。

常见的需要加const 的引用对象包括：常量，临时拷贝，函数值返回，被const修饰的变量等

void TestConstRef()
{
    const int a = 10;
    //int& ra = a;   // 该语句编译时会出错，a为常量
    const int& ra = a;
    // int& b = 10; // 该语句编译时会出错，b为常量
    const int& b = 10;
    double d = 12.34;
    //int& rd = d; // 该语句编译时会出错，类型不同
    const int& rd = d;
}

5.4 引用的使用场景

1. 做参数
引用做参数时，与C语言中将变量的指针做参数是一样的效果，相当于将参数本身传到当中去了，对参数的更改就是对变量本身的更改。

void Swap(int& left, int& right)
{
   int temp = left;
   left = right;
   right = temp;
}

2. 做返回值
当引用做返回值时，要将引用符号放到函数名前面，此时引用的是函数返回值。

注意：
做返回值引用，只能引用出了函数不会立刻被销毁的变量，如果引用了出了函数就会被销毁的变量，在使用时会出现很大的问题。

int& Count()
{
   static int n = 0;//静态变量，出了函数不会被销毁
   n++;
   // ...
   return n;
}

6. 内联函数

6.1 内联函数概念

内联函数的使用是为了替代宏，在使用宏写宏函数的时候，很容易出错，例如使用宏写一个加法的宏函数，会出现下面的场景：

#define Add(x,y) x+y;
#define Add(x,y) (x+y);
#define Add(x,y) x+y
#define Add(x,y) (x)+(y);
#define Add(x,y) ((x)+(y))
#define Add (x,y) x+y;

以上写法都是错误的，正是因为宏函数在编写的时候极容易出现各种问题，因此才有了内联函数。

内联函数使用如下：

inline int Add(int left,int right)
{
	return left+rigth;
}

int main()
{
	int ret=0;
	ret=Add(1,2);
	return 0;
}

内联函数在本质上和宏函数是一致的，都是在使用的地方直接展开。

6.2 内联函数的特性

inline是一种以空间换时间的做法，如果编译器将函数当成内联函数处理，在编译阶段，会
用函数体替换函数调用，缺陷：可能会使目标文件变大，优势：少了调用开销，提高程序运行效率。
inline对于编译器而言只是一个建议，不同编译器关于inline实现机制可能不同，一般建
议：将函数规模较小(即函数不是很长，具体没有准确的说法，取决于编译器内部实现)、不
是递归、且频繁调用的函数采用inline修饰，否则编译器会忽略inline特性。
inline不建议声明和定义分离，分离会导致链接错误。因为inline被展开，就没有函数地址
了，链接就会找不到。

#include <iostream>
using namespace std;
inline void f(int i);
// F.cpp
#include "F.h"
void f(int i)
{
 cout << i << endl;
}
// main.cpp
#include "F.h"
int main()
{
 f(10);
 return 0;
}
// 链接错误：main.obj : error LNK2019: 无法解析的外部符号 "void __cdecl 
f(int)" (?f@@YAXH@Z)，该符号在函数 _main 中被引用

总结

命名空间、输入&输出、缺省参数、函数重载、引用、内联函数是C++入门的基础概念之一，熟练掌握这些概念会对以后的学习带来巨大的帮助。

小小分享君

关注

34
点赞
踩
27

收藏

觉得还不错? 一键收藏
8
评论
C++入门基础认知--命名空间、输入&输出、缺省参数、函数重载、引用、内联函数

定义命名空间，需要使用到namespace关键字，后面跟命名空间的名字，然后接一对{}即可，{}中即为命名空间的成员。命名空间中可以放变量、函数、自定义类型等，只要是符合语法，基本都可以放在里面。此外，命名空间还可以嵌套使用。namespace MySpace//MySpace 是这个命名空间的名字，根据实际情况自己取定//变量rand 的名字与库函数rand（）重复//在命名空间中可以存在，但不可以直接在命名空间之外使用。
复制链接

扫一扫