C++入门语法（命名空间&缺省函数&函数重载&引用&内联函数&nullptr）

萧瑟其中～

已于 2024-04-07 09:56:03 修改

阅读量827

点赞数 24

分类专栏： C++ 文章标签： c++ 开发语言

于 2024-04-06 23:08:23 首次发布

本文链接：https://blog.csdn.net/2301_79171011/article/details/137212641

版权

C++ 专栏收录该内容

15 篇文章 0 订阅

订阅专栏

前言

这一篇文章开始了我与C++这门语言的相遇，我会持续更新有关C++的文章，既是我对学习C++之后的复习与总结，也是一种分享知识的方式。这篇的主要内容围绕的是C++入门语法讲解，许多语法都是本博士C++之父，对C语言的改进。

1. 什么是C++

     C语言是结构化和模块化的语言，适合处理较小规模的程序。对于复杂的问题，规模较大的程序，需要高度的抽象和建模时，C语言则不合适。为了解决软件危机， 20世纪80年代，计算机界提出了OOP(object oriented programming：面向对象)思想，支持面向对象的程序设计语言应运而生。
      1982年，Bjarne Stroustrup博士在C语言的基础上引入并扩充了面向对象的概念，发明了一种新的程序语言。为了表达该语言与C语言的渊源关系，命名为C++。因此：C++是基于C语言而产的，它既可以进行C语言的过程化程序设计，又可以进行以抽象数据类型为特点的基于对象的程序设计，还可以进行面向对象的程序设计。C++几乎可以创建任何类型的程序：游戏、设备驱动程序、HPC、云、桌面、嵌入式和移动应用等。甚至用于其他编程语言的库和编译器也使用C++编写。
        C++拥有计算机运行的实用性特征，同时还致力于提高大规模程序的编程质量与程序设计语言的问题描述能力。

2. C++关键字

C++总计有63个关键字，C语言有32个关键字。

3. 命名空间

在C和C++中，我们会大量使用变量、函数和类，这些变量、函数和类的名称都将存在于全局作用域中，可能会导致很多冲突。如下面的例子：

#include <stdio.h>
#include <stdlib.h>

int rand = 10;
// C语言没办法解决类似这样的命名冲突问题，所以C++提出了namespace来解决

int main()
{
    printf("%d\n", rand);
    return 0;
}

错误列表：

我们在全局作用域中定义了rand变量并初始化，但是stdlib库中有rand函数，库函数和全局变量产生了命名冲突，为了避免这种情况出现，就要使用C++提供的namespace关键字。

3.1 命名空间的定义

定义一个命名空间，要用到namespace关键字，后面跟命名空间的名字，然后接一对花括号即可，{}中是命名空间的成员。

命名空间是可以嵌套的，但是一般最多嵌套两三层。
同一工程中不同的文件允许存在相同的命名空间，编译器最后会合成同一个命名空间。

// 1. 正常的命名空间定义
namespace User
{
	// 命名空间中可以定义变量/函数/类型
	int rand = 10;
	int Add(int left, int right)
	{
		return left + right;
	}

	struct Node
	{
		struct Node* next;
		int val;
	};
}


//2. 命名空间可以嵌套
// test.cpp
namespace N1
{
	int a;
	int b;
	int Add(int left, int right)
	{
		return left + right;
	}
	namespace N2
	{
		int c;
		int d;
		int Sub(int left, int right)
		{
			return left - right;
		}
	}
}


//3. 同一个工程中允许存在多个相同名称的命名空间,编译器最后会合成同一个命名空间中。
// ps：一个工程中的test.h和上面test.cpp中两个N1会被合并成一个
// test.h
namespace N1
{
	int Mul(int left, int right)
	{
		return left * right;
	}
}

3.2 命名空间的使用

看看下面的例子，先定义一个命名空间，然后再main函数中打印出User中rand变量的值。

#include <stdio.h>
#include <stdlib.h>
namespace User
{   // 命名空间中可以定义变量/函数/类型
	int rand = 20;
	int Add(int left, int right)
	{
		return left + right;
	}

	struct Node
	{
		struct Node* next;
		int val;
	};
}

int main()
{
	printf("%d\n", rand);
	return 0;
}

运行之后的结果：

明明已经将rand变量放入User的命名空间，应该打印20在屏幕上，可是却打印了一个很大的数字，这是为什么呢？我们先来了解一个C++程序编译默认查找变量和函数的顺序。

当前局部作用域
当前全局作用域

为什么不去命名空间查找该变量或者函数呢，我们可以做一个类比：

命名空间比作一块张三的私有田，是私人领域。
局部作用域就是一块公有田。
全局作用域就是一块野外的田地。

如果需要某种蔬菜，一般是到自己家的田地里寻找，然后再去外面的野地，除非张三同意在他的田里摘取蔬菜，不然不回去私人的田地寻找。所以跟上面的例子类似，搜索完局部作用域和全局作用域，除非有明确说明，不然不会在某个命名空间中搜索。

因此，上面的代码要打印rand的整型值，但是没有特别声明，所以先找当前局部作用域寻找，再到全局变量中寻找。而在stdlib头文件，rand是一个输出随机值的函数，所以打印的是这个函数的地址，那我们应该怎么打印User命名空间里的rand变量呢？

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

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

int main()
{
   printf("%d\n", User::rand);
   return 0;    
}

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

using User::rand;

int main()
{
   printf("%d\n", rand);
   return 0;    
}

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

using namespace User;

int main()
{
   printf("%d\n", rand);
   return 0;    
}

注意事项：

在大型工程项目中一般不支持命名空间展开，因为编译器默认查找顺序，是先搜索局部作用域，再全局作用域和指定的命名空间展开。如果两个命名空间同时展开并且里面有同名的函数和变量，就会产生歧义。
但是在日常练习中，会使用一些常用函数，那么就可以使用using namespace std，std是把C++所有的标准库合在一起的命名空间，方便使用。

4. C++输入和输出

C语言的输入输出函数是scanf和printf函数。那么C++的“helloworld”是怎么样的呢？

#include<iostream>
// std是C++标准库的命名空间名，C++将标准库的定义实现都放到这个命名空间中
using namespace std;

int main()
{
    cout<<"Hello world!!!"<<endl;
    return 0;
}

本博士对C语言进行修改，在C++中给出cin和cout函数，分别对应输入和输出函数。

其中cin表示console input，即标准输入对象（键盘），cout表示console output，即标准输出对象（控制台）。
cout和cin是全局的流对象，endl是特殊的C++符号，表示换行输出，他们都包含在包含<iostream >头文件中，所以使用时必须包含<iostream>头文件。
<<是流插入运算符，>>是流提取运算符。
使用C++输入输出更方便，不需要像printf/scanf输入输出时那样，需要手动控制格式。
C++的输入输出可以自动识别变量类型。
实际上cout和cin分别是ostream和istream类型的对象，>>和<<也涉及运算符重载等知识。

#include <iostream>
using namespace std;
int main()
{
  int a = 10;
  double b = 3.14;
  char c = ‘a’;
   
  // 可以自动识别变量的类型
  cin>>a;
  cin>>b>>c;
   
  cout<<a<<endl;
  cout<<b<<"  "<<c<<endl;
  return 0;
}

5. 缺省函数

5.1 概念

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

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

5.2 缺省参数分类

全缺省参数，全部都有缺省值。

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

半缺省参数，只有部分缺省。但是半缺省参数必须从右往左依次给，不能隔开。

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

还有注意，缺省参数不能再函数声明和定义中同时出现

// Fun.h
 void Func(int a = 10);
 
// Fun.cpp
 void Func(int a = 20)
{}
 
// 注意：如果生命与定义位置同时出现，恰巧两个位置提供的值不同，那编译器就无法确定到底该
用那个缺省值。

6. 函数重载

6.1 概念

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

#include<iostream>
using namespace std;
// 1、参数类型不同
void Swap(int left, int right)
{
	cout << "void Swap(int left, int right)" << endl;
	int tmp = left;
	left = right;
	right = tmp;
}

void Swap(double left, double right)
{
	cout << "void Swap(double left, double right)" << endl;
	int tmp = left;
	left = right;
	right = tmp;
}

// 2、参数个数不同
void fun()
{
	cout << "fun()" << endl;
}
void fun(int a)
{
	cout << "fun(int a)" << endl;
}

// 3、参数类型顺序不同
void fun(int a, char b)
{
	cout << "fun(int a,char b)" << endl;
}
void fun(char b, int a)
{
	cout << "fun(char b, int a)" << endl;
}

int main()
{
	Swap(10, 20);
	Swap(10.1, 20.2);

	fun();
	fun(10);

	fun(10, 'a');
	fun('a', 10);

	return 0;
}

6.2 为何C++支持函数重载

C++支持函数重载，但是C语言却不支持函数重载，这是什么原因呢？

这是正常一个程序运行的步骤，先进行编译，再进行链接，最后变成一个可执行程序。

⽽编译⼜可以分解成：预处理（有些书也叫预编译）、编译、汇编三个过程。最后会形成一个.o文件，再到链接的步骤。如果对这方面有些困惑的小伙伴，可以看起之前写的关于编译和链接文章http://t.csdnimg.cn/Je6r0。

我们有两个文件a.cpp和test.cpp，假设Add和func函数的实现放在a.cpp文件下，然后在test.cpp文件中调用Add和func函数。

编译的工作完成之后，还没有链接之前，因为Add和func函数的地址在a.o中，而test.o的目标文件中没有Add和func函数地址，无法调用该函数。那该怎么办呢？
链接阶段就是专门处理这中问题的，链接器链接器看到test.o调用Add和func，但是没有Add和func的地址，就会到a.o的符号表中找Add和func的地址，然后链接到一起。
那么链接时，面对Add和func函数，链接接器会使用哪个名字去找呢？这里每个编译器都有自己的函数名修饰规则，这是编译过程的工作。
在Linux下g++的修饰规则下，C语言的函数名经过修饰后没有发生变化，而C++的函数名修饰后变成修饰后变成【_Z+函数长度+函数名+类型首字母】。比如下面的Add和func函数，分别是“_Z3Addii”，“_Z4funcid”。
通过这里就理解了C语言没办法支持重载，因为同名函数没办法区分。而C++是通过函数修饰规则来区分，只要参数不同，修饰出来的名字就不一样，就支持了重载。
如果两个函数函数名和参数是一样的，返回值不同是不构成重载的，因为调用时编译器没办法区分。

// a.cpp文件下
int Add(int x, int y)
{
    return x + y;
}

void func（int a, double c）
{}

// test.cpp文件下
int Add(int x, int y);
void func（int a, double c;

int main()
{
    Add(x, y);
    func(1, 2.2)    

    return 0;
}

7. 引用

7.1 概念

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

// 写法：类型& 引用变量名(对象名) = 引用实体；
void TestRef()
{
   int a = 10;
   int& ra = a;//<====定义引用类型

   printf("%p\n", &a);
   printf("%p\n", &ra);
}

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

7.2 特性

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

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

7.3 常引用

第一种错误，a变量的类型是一个不可改变的整型值。如果引用整型类型，定义一个ra，此时我们可以对ra进行修改，从而影响a。这是不被允许的，是权限放大的体现。
第二种错误也是一个权限放大。我们对一个整型常量值10做一个引用，而引用b可以被修改，与常量的不可修改性质产生冲突。
第三种错误，我们将一个双浮点精度的变量，却引用整型变量，取别名，这会产生隐式类型转换。首先双浮点精度的d变量的值会转换成整型变量的值，这个值存放在一个临时变量中，而临时变量也具有常性，即不可修改的性质。必须在整型变量前加上一个const，体现常性。

void TestConstRef()
{
   //1.
   const int a = 10;
   //int& ra = a;   // 该语句编译时会出错，a为常量
   const int& ra = a;
   
   // 2.
   // int& b = 10;  // 该语句编译时会出错，b为常量
   const int& b = 10;

   //3. 
   double d = 12.34;
   //int& rd = d;  // 该语句编译时会出错，类型不同
   const int& rd = d;
}

7.4 引用与指针的区别

在语法概念上引用就是一个别名，没有独立空间，和其引用实体共用同一块空间。

#include <iostream>
using namespace std;

int main()
{
	int a = 0;
	int& b = a;  //语法上不开空间
	int* p = &a; //语法上要开空间

	cout << sizeof(a) << endl;
	cout << sizeof(b) << endl;//a的别名，相当于求a的内存大小

	b++;//相当于a++
	p++;//地址加上一个整型变量空间大小的值

	return 0;
}

在底层实现上实际是有空间的，因为引用是按照指针方式来实现的。

int main()
{
    int a = 10;

    int& ra = a;
    ra = 20;

    int* pa = &a;
    *pa = 20;

    return 0;
}

引用和指针的不同点:

引用概念上定义一个变量的别名，指针存储一个变量地址。
引用在定义时必须初始化，指针没有要求。
引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体。
没有NULL引用，但有NULL指针。
在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占4个字节)。
引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小。
有多级指针，但是没有多级引用。
访问实体方式不同，指针需要显式解引用，引用编译器自己处理。
引用比指针使用起来相对更安全。

7.5 传值、传引用效率比较

以值作为参数或者返回值类型，在传参和返回期间，函数不会直接传递实参或者将变量本身直接返回，而是传递实参或者返回变量的一份临时的拷贝，因此用值作为参数或者返回值类型，效率是非常低下的，尤其是当参数或者返回值类型非常大时，效率就更低。

根据引用和指针的比较，我们知道引用底层其实是按照指针方式实现的。所以引用不管是传值，还是返回变量跟指针的传址调用类似，效率高。

#include <time.h>
struct A { 
	int a[10000]; 
};
void TestFunc1(A a) {}
void TestFunc2(A& a) {}
void TestRefAndValue()
{
	A a;
	
	// 以值作为函数参数
	size_t begin1 = clock();//计算系统开始的时间，单位毫秒
	for (size_t i = 0; i < 10000; ++i)
		TestFunc1(a);
	size_t end1 = clock();
	
	// 以引用作为函数参数
	size_t begin2 = clock();
	for (size_t i = 0; i < 10000; ++i)
		TestFunc2(a);
	size_t end2 = clock();
	
	// 分别计算两个函数运行结束后的时间
	cout << "TestFunc1(A)-time:" << end1 - begin1 << endl;
	cout << "TestFunc2(A&)-time:" << end2 - begin2 << endl;
}

8. 内联函数

8.1 概念

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

如果在上述函数前增加inline关键字将其改成内联函数，在编译期间编译器会用函数体替换函数的调用。

8.2 特性

inline是一种以空间换时间的做法，如果编译器将函数当成内联函数处理，在编译阶段，会用函数体替换函数调用，缺陷：可能会使目标文件变大，优势：少了调用开销，提高程序运行效率。
inline对于编译器而言只是一个建议，不同编译器关于inline实现机制可能不同，一般建议：将函数规模较小(即函数不是很长，具体没有准确的说法，取决于编译器内部实现)、不是递归、且频繁调用的函数采用inline修饰，否则编译器会忽略inline特性。下图为《C++prime》第五版关于inline的建议：

内敛说明知识向编译器发出的一个小请求，编译器可以选择忽略这个请求。

inline不建议声明和定义分离，分离会导致链接错误。因为inline被展开，就没有函数地址了，链接就会找不到。

// F.h
#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;
}

8.3 宏和内敛函数

宏在C语言经常使用，有哪些优缺点呢？

优点：

增强代码的复用性。
提高性能。

缺点：

不方便调试宏。（因为预编译阶段进行了替换）
导致代码可读性差，可维护性差，容易误用。
没有类型安全的检查。

在C++中，本博士在改进C语言中，就新增了内联函数的用法，就是为了替代宏。

9. C++98中的指针空值

在良好的C/C++编程习惯中，声明一个变量时最好给该变量一个合适的初始值，否则可能会出现不可预料的错误，比如未初始化的指针。如果一个指针没有合法的指向，我们基本都是按照如下方式对其进行初始化：

void TestPtr()
{
    int* p1 = NULL;
    int* p2 = 0;
    // ……
}

NULL实际是一个宏，在传统的C头文件(stddef.h)中，可以看到如下代码：

#ifndef NULL
#ifdef __cplusplus
#define NULL    0
#else
#define NULL    ((void *)0)
#endif
#endif

可以看到，NULL可能被定义为字面常量0，或者被定义为无类型指针(void*)的常量。不论采取何种定义，在使用空值的指针时，都不可避免的会遇到一些麻烦，比如：

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

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

int main()
{
    f(0);
    f(NULL);
    f((int*)NULL);
    return 0;
}

程序本来是想通过f(NULL)调用指针版本的f(int*)函数，但是由于NULL被定义成0，造成错误。

在C++98中，字面常量0既可以是一个整形数字，也可以是无类型的指针(void*)常量，但是编译器默认情况下将其看成是一个整形常量，如果要将其按照指针方式来使用，必须对其进行强转(void*)0。

在使用nullptr表示指针空值时，不需要包含头文件，因为nullptr是C++11作为新关键字引入的。
在C++11中，sizeof(nullptr) 与 sizeof((void*)0)所占的字节数相同。
为了提高代码的健壮性，在后续表示指针空值时建议最好使用nullptr。