C++基础内容--命名空间/函数重载/引用/内联函数/auto关键字/for循环/指针空值nullptr

其他 2020-10-14 18:37:50 阅读次数: 0

  在本节博客中，主要介绍C++中的命名空间，C++的输入和输出、缺省参数、函数重载、引用、内联函数、auto关键字、基于范围的for循环和指针空值—nullptr这样内容，内容是C++的基础入门，在后续的博客中会继续连载C++的基础和进阶内容。

命名空间

  在C/C++中，变量、函数和类都是大量存在的，这些变量、函数和类的名称都将存在于全局作用域中，可能会导致很多冲突。使用命名空间的目的是对标识符的名称进行本地化，以避免命名冲突或名字污染，namespace关键字的出现就是针对这种问题。

命名空间的定义
  定义的时候需要使用namespace关键字，后面跟命名空间的名字，然后接一对{}即可，{}中即为命名空间的成员。命名空间：实际就是一个带有名字的作用域（::作用域运算符）
namespace N
{
成员：变量 函数 其他…
}

命名空间的使用

  • 直接在成员前增加 N::，例如N::a,即访问N命名空间中的a；
  • using N::a ,相当于将a当成全局变量使用；
  • using namespace N;相当于将N命名空间中的所有成员当成当前文件中的全局变量使用；
  • 在C++中，一个工程中可以出现相同的命名空间,编译器最终将相同命空间的内容合并到一块，注意成员名之间不要冲突；
  • 命名空间之间可以嵌套。

C++的输入与输出

  • cin来进行标准输入 — 数据是通过键盘来输入的；
  • cout来进行标准输出 — 数据输出到控制台；
  • cin和cout最大优势是不需要记忆格式的控制，而c语言中，输出格式都会对应相应的格式输出；
    例如;int a; double b; char c;
    cin >> a >> b >> c;
    cout << a << b << c << endl;
    打印的结果为：adc
      **注意：**在使用时cin和cout时需要添加头文件和std(标准的命名空间)，标准库中的基本内容都是在std中定义的。

c语言和c++的区别

1 参数类表：
  在C语言中，如果一个函数没有参数，可以传递任意多个参数，原因是c语言编译器对函数参数检测不是很严格
  在C语言中，如果一个函数没有参数时，必须明确指定函数的参数类型是void，例如void testFind(void);
  在C++中，C++的编译器对函数的检测更为严格，如果一个函数void testFind()没有参数，在调用过程中，编译器会报错
2 返回值不同
  如果在C语言中，一个函数没有定义返回值类型，例如 test(){},C语言编译器则认为该函数的返回值为整形，这是因为C语言编译器对函数的返回值类型检测不严格
  如果在C++中，一个函数没有定义返回值类型，例如 test(){}，C++编译器会直接报错，这是因为C++编译器对函数返回值类型检测十分严格。
3 在C++中一个函数的参数可以带默认值
缺省参数：是声明或定义函数时为函数的参数制定一个默认值，在调用函数时，如果没有指定实参则使用默认值，否则使用实参，简单来说类型于一个备胎选项

缺省参数

  1. 全缺省参数：所有参数都带有默认值
  2. 半缺省参数：部分参数带有默认值，注意半缺省参数从右向左依次给出，不能间隔给
  3. 缺省参数不能再声明和定义同时给出，因为给的默认值不一样的话，编译器不知道使用哪个值
  4. 缺省参数必须是常量或者全局变量
  5. C语言不支持缺省参数
//全缺省参数
void TestFunc1(int a = 10, int b = 20, int c = 30)
{
    
    
	cout << a <<" "<< b << " " << c << endl;
}

//半缺省参数
void TestFunc2(int a, int b = 20, int c = 10)
{
    
    
	cout << a << " " << b << " " << c << endl;
}

int main()
{
    
    
	TestFunc1(100);//100, 20, 30
	TestFunc1();//10, 20, 30
	TestFunc2(10);//10 20 10
	TestFunc2(10, 30);//10 30 10
	return 0;
}

函数重载

  函数重载:是函数的一种特殊情况，C++允许在同一作用域中声明几个功能类似的同名函数，这些同名函数的形参列表(参数个数或类型或顺序)必须不同，常用来处理实现功能类似数据类型不同的问题，注意：与返回值类型是否相同无关。
为什么C语言不支持函数重载？
  因为c语言对函数的名字修饰规则非常简单，仅仅只是在函数名后面加了"_",假设两个函数Add(int a, int b)和Add(char a, char b),在C语言编译后函数名都是_Add()类型函数，编译自然会失败。

c++如何支持函数重载？
在这里插入图片描述
  C++编译器在对函数名字修饰时，最终将参数类型信息编译到名字当中，只要类型不一样，最后编译后得函数名就不一样，就不会产生冲突。

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

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

char Add(char left, char right)
{
    
    
	return left + right;
}

int main()
{
    
    
	Add(10,20);
	Add(10.0, 20.0);
	Add('1', '2');
	return 0;
}

在编译器编译阶段，会对传递函数实参的类型进行推演，然后根据推演的结果选择对应类型的函数进行转化；
注意：
推演完成后，如果有合适的类型重载的函数则调用，否则会发生隐式类型转化–>转化后有合适的类型进行调用，否则报错；
例如：Add(‘1’, ‘2’); //char char -->找Add(char, char)函数，假如该函数没有，但有Add(int, int)函数,char和int类型之间可以发生隐式类型转化。

extern “C”
  有时候在C++工程中可能需要将某些函数按照C的风格来编译，在函数前加extern “C”，意思是告诉编译器，将该函数按照C语言规则来编译。

//工程是C++工程，但是想要按照C语言的方式编译代码
extern "C" int Add(int left, int right);

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

传值和传址的区别？

  1. 传值：形参将来接收到的是实参的一份临时拷贝，在函数中如果对形参进行改变，不会影响外部的实参；
  2. 传址：形参将来放置的是实参的地址，通过对形参解引用拿到实参，对形参解引用进行修改，实际上就是对外部实参的修改；
  3. 传址比传值效率高：传值需要的是实参本身的一份临时拷贝，如果实参类型比较大将来拷贝的副本就比较大；
    传址需要的是实参地址的一份拷贝，形参只占4个字节（32位），传址不仅效率高，而且节省空间；
  4. 传址比传值更安全—指针必须要判空；
  5. 传值比传址代码的可读性高。

传值和传址有什么优缺点？
传值优点：1.代码的可读性高，更为安全 ;
     2.不想通过形参改变实参时，传值的作用会更明显；
   缺点: 1.传值效率低、浪费空间（传递的是实参的副本）;
     2.如果想要通过形参改变外部实参，不可以；
传址优点: 1. 传参的效率高、节省空间（传递的是实参的地址–32位平台4个字节）;
     2. 可以通过形参改变外部实参；
  缺点：1. 安全性低，可读性低 ;
     2. 如果不想通过形参改变外部的实参时，可能产生副作用。

引用

  引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。
  引用格式：类型& 引用变量名(对象名) = 引用实体。

void TestRef()
{
    
    
	int a = 10;
	//ra就是a的别名,ra和a在底层就是公用一个实体，即公用一块内存空间
	int& ra = a;
	cout << &a << " " << &ra << endl;//0058F6A4 0058F6A4
}

void SetNULLPtr(int*& p)
{
    
    
	p = NULL;
}

void SetNULLPtr(int** p)
{
    
    
	//*p就是实参本身 
	*p = NULL;
}

int main()
{
    
    
	int a = 10;
	int* pa = &a;
	*pa = 20;

	SetNULLPtr(pa);
	SetNULLPtr(&pa);
	TestRef();
	return 0;
}

引用特性：

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

常引用–>const类型的引用

int main()
{
    
    
	const int a = 10;//a是不能被修改的
	const int& ra = a;//正确

	//int& ra = a;//错误
	             //如果普通类型的引用变量ra去引用a，可以修改a，否则修改ra则就会把a修改掉
	
	double d = 12.34;
	//double& rd = d;//正确
	// rd = 23.34;

	const int& rd = d;//编译器就创建了一个临时int型变量，
	               //rd就不能直接引用，而int和double类型之间可以发生隐式类型转化
	             //临时空间具有常性---不能被修改，因此必须是使用const int&来引用
	return 0;
}

引用的应用场景：

  1. 概念： 直接给某个实体去别名—为了写代码简单，例如a.b._b = 10; 引用 int& rb = a.b._b; rb = 10;
  2. 作为函数的返回值：可以达到指针类似的效果----即可以通过形参改变外部的实参；
    void f(T& a):可以通过形参a改变外部实参；
    void f(const T& a): 如果不想通过形参改变外部实参，最终可以将参数前加一个const进行限制，程序的安全性就高；
    函数的返回值：一定不要返回函数栈上的空间。
#include <ctime>

struct A
{
    
    
	int array[10000];
};

void TestValue(A a)
{
    
    }

void TestRef(A& a)
{
    
    }

void TestPtr(A* a)
{
    
    }

void TestFunc()
{
    
    
	A a;

	//传值，在传参期间需要进行实参的一份拷贝
	size_t begin1 = clock();
	for (int i = 0; i < 100000; i++)
		TestValue(a);
	size_t end1 = clock();

	//引用是别名，在传参期间不需要进行拷贝
	size_t begin2 = clock();
	for (int i = 0; i < 100000; i++)
		TestRef(a);
	size_t end2 = clock();

	//传指针，在传参期间不需要进行对象的拷贝--拷贝的是对象的地址--32位平台四个字节
	size_t begin3 = clock();
	for (int i = 0; i < 100000; i++)
		TestRef(a);
	size_t end3 = clock();

	cout << "传值性能：" << end1 - begin1 << endl;//100
	cout << "传引用性能：" << end2 - begin2 << endl;//1
	cout << "传指针性能：" << end3 - begin3 << endl;//1
}

总结：传值效率比传引用效率高。
在C++中，对于自定义类型的参数一般都是按照引用的方式来传递的T& constT&；
在C++中，传指针和传引用所耗费的时间差不对。

引用在底层中实现方式
对比指针和引用在底层中的调用汇编代码如下：
在这里插入图片描述
对比两函数之间分别用指针和引用实现如下：
在这里插入图片描述
结论：在底层实现方式上，引用就是按照指针的方式来实现的，在底层处理中，没有引用一说
注意：引用变量实际是有空间的，该空间中存放室的是具体引用实体的地址。

引用和指针的区别：

  1. 引用在定义时必须初始化，指针没有要求；
  2. 引用在初始化是引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任意一个同类型实体；
  3. 没有NULL引用，但有NULL指针；
  4. 在sizeof中含义不同，引用结果为引用类型的大小，但指针始终是地址空间所占的字节个数（4字节或8字节大小）；
  5. 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小；
  6. 有多级指针，但是没有多记引用；
  7. 访问的方式不同，指针需要显示解引用，引用编译器自己处理；
  8. 引用比指针使用起来相对安全；
    两个易错的代码用来加深引用和指针的理解：
    代码1：
void  Swap(int& left, int& right)
{
    
    
	int temp = left;
	left = right;//这里代码崩溃
	right = temp;
}

int main()
{
    
    
	int a = 10;
	int b = 20;
	int* pb = NULL;
	*pb = 100;//对空指针解引用，代码执行期间崩溃
	Swap(a, *pb);//但是该位置的空指针，代码在执行期间没有崩溃
	return 0;
}

说明：在传参时，看起来是按照值的方式传递，但在编译器在编译代码时，检测到Swap的两个引用类型的参数转换为指针。
因此：Swap(a,*pb)–>编译成：Swap(&a, pb)
代码2

int main()
{
    
    
	const int a = 10;
	int* pa = (int*)&a;
	*pa = 100;

	cout << *pa << endl;//100
	cout << a << endl;//10  const修饰的a在编译前已经被替换成10了
	return 0;
}

说明：在C++中被const修饰的变量具有宏替换的属性，而且具有宏替换的属性，替换发生在程序的编译阶段。
宏：在预处理阶段发生替换–代码还没有编译-预处理器直接替换，不会进行类型检测，所以安全性不高。
const修饰：是在编译阶段进行替换，会进行参数类型检测，安全性高。所以在C++中，建议用const修饰的常量代替宏常量。
  注意：C语言和C++被const修饰的常量有所不同，C语言中被const修饰的常量不能被称为常量，它仍然是一个变量，只不是该变量不能被修改，即在C语言中被const修饰的常量是不能被修改的变量。

相关的面试题
说说宏的优缺点？
宏常量
优点：一改全改，降低了出错的概率，提高代码的可读性；
缺点：在预处理阶段进行替换，不会进行类型检测，代码的安全性较低；
所以在C++中，建议用const修饰的常量代替宏常量；
宏函数
优点：不是函数，少了函数调用的开销，可以提高程序执行的运行效率；可以减少代码量，因为宏函数可以封装多条语句，但不是提高代码的复用率，因为宏在预处理阶段展开了；
缺点：宏函数在预处理阶段被替换，不会进行类型检测，代码的可读性比较低；宏不能调试；宏容易出错，每个部分都要加括号；每个使用宏函数的位置都会被展开，会造成代码的膨胀。

内联函数

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

  1. inline是一种以空间换时间的做法，省去调用函数额开销。所以代码很长或者有循环/递归的函数不适宜使用作为内联函数。
  2. inline对于编译器而言只是一个建议，编译器会自动优化，如果定义为inline的函数体内有循环/递归等等，编译器优化时会忽略掉内联。
  3. inline不建议声明和定义分离，分离会导致链接错误。因为inline被展开，就没有函数地址了，链接就会找不到。

宏和内联函数的区别？
内联函数
  优点：因为是函数，参数有设置，因此在编译阶段会进行参数类型检测，代码的安全性高，在Debug模式下默认不会展开，可以进行调试，也可以通过对编译器的设置来验证是否展开了
写的时候期间不用想宏函数导出加括号，实现起来简单，不会产生副作用；在编译阶段已经展开，少了函数调用的开销，可以提高程序的运行效率。
  缺点：使用内联函数的位置都会被展开，会造成代码的膨胀。
在这里插入图片描述
如果在上述函数前增加inline关键字将其改成内联函数，在编译期间编译器会用函数体替换函数的调用。

查看方式：
在release模式下，查看编译器生成的汇编代码中是否存在call Add；
在debug模式下，需要对编译器进行设置，否则不会展开(因为debug模式下，编译器默认不会对代码进行优化，以下给出vs2013的设置方式)。
在这里插入图片描述
在C++中，有什么方式可以代替宏？
常量定义 换用const
函数定义 换用内联函数

auto关键字(C++11)

  简介：在早期C/C++中auto的含义是：使用auto修饰的变量，是具有自动存储器的局部变量，但遗憾的是一直没有人去使用它。
  C++11中，标准委员会赋予了auto全新的含义即：auto不再是一个存储类型指示符，而是作为一个新的类型指示符来指示编译器，auto声明的变量必须由编译器在编译时期推导而得。

int main()
{
    
    
	auto a = 10;
	auto b = "1234";
	auto c = 12.34;
	auto d = a + 10;

	cout << typeid(a).name() << endl;//int
	cout << typeid(b).name() << endl;//char const *
	cout << typeid(c).name() << endl;//double
	cout << typeid(d).name() << endl;//int
	return 0;
}

注意：
在用auto定影变量时，必须对变量进行初始化；
因为编译器在编译期间要根据变量的初始化表达式来推演该变量的实际表达式；
将该实际类型推演出来之后替换auto；
auto此时只是一个占位符；
在编译器编译时，编译器推演d的初始化表达式a+10的类型为int，最终将int替换d之前的auto；

auto不能推导的场景

  1. auto不能作为函数的参数
    此处代码编译失败，auto不能作为形参类型，因为编译器无法对a的实际类型进行推导
void TestAuto(auto a)
{
    
    }
  1. auto不能直接用来声明数组
void TestAuto()
{
    
    
	int a[] = {
    
    1,2,3};
	auto b[] = {
    
    4，5，6};
}

因为数组中元素的类型可能不一样，用auto来声明数组的类型的话，auto就不知道该去声明哪种类型了。
3. 为了避免与C++98中的auto发生混淆，C++11只保留了auto作为类型指示符的用法；
4. auto在实际中最常见的优势用法就是跟以后会讲到的C++11提供的新式for循环，还有lambda表达式等进行配合使用。

基于范围的for循环(C++11)

范围for的语法
在C++98中需要遍历一个数组的话，我们可以按照以下方式进行：

void TestFor()
{
    
    
	int array[] = {
    
     1, 2, 3, 4, 5 };
	for (int i = 0; i < sizeof(array) / sizeof(array[0]); ++i)
		array[i] *= 2;
	for (int* p = array; p < array + sizeof(array)/ sizeof(array[0]); ++p)
		cout << *p << endl;
}

  在遍历一个数组的时候，假设一个有范围的数组需要遍历，我们需要求出来数组中的大小来确定循环的次数，在求解的过程中我们可能或多或少的会犯错。因此在C++11中引入了基于范围for循环。for循环后面的括号有冒号“ ：”分为两部分：第一部分是范围内用于迭代的变量，第二部分是表示被迭代的范围。 举例如下：

void TestFor()
{
    
    
	int array[] = {
    
     1, 2, 3, 4, 5 };
	for(auto& e : array)
		e *= 2;
	for(auto e : array)
		cout << e << " ";
	return 0;
}

在此例子中，auto& e 和 auto e代表的是范围内用于迭代的变量，array代表的是迭代的范围。
注意：与普通循环类似，可以用continue来结束本次循环，也可以用break来跳出整个循环。

范围for的使用条件

  1. for循环迭代的范围必须是确定的

  对于数组而言，数组的范围就是数字第一个元素到最后一个元素的范围；对于类而言，范围的确定应该提供begin和end方法来确定范围。错误举例如下，在本例中，数组的范围没用确定，所以不能使用范围for循环。

void TestFor(int array[])
{
    
    
	for(auto& e : array)
	cout<< e <<endl;
}
  1. 迭代的对象要实现++和==的操作。(关于迭代器这个问题，以后会讲，现在大家了解一下就可以了)；

指针空值nullptr(C++11)

在定义一个指针的时候，我们开始对其进行初始化时，通常将指针的指向赋值给空指针。
  实际上空指针的定义是一个宏#define NULL 0。因此实际的调用过程是TestFunc(NULL)---->预处理阶段 ——>TestFunc(0);在传统的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表示指针为空值。

注意：

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

猜你喜欢

转载自blog.csdn.net/aaaaauaan/article/details/107452425
今日推荐
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
GCC 14.1 发布
面壁智能发布 Eurux-8x22B 开源大模型 —— 堪称「理科状元」
开源日报 | 谷歌扶持鸿蒙上位；开源Rabbit R1；Docker加持的安卓手机；微软的焦虑和野心；海尔电器把开放平台关了
中国码农的“35岁魔咒”
蘭雅 CorelDRAW 插件 2024.5.1 国际劳动节版，免费下载
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
周排行
Java自定义时间格式
同步整形电路
在开发中最最最常用的字符串的属性大集合
Linux 查看端口占用并杀掉
Java基础四：ArrayList
多线程之死锁就是这么简单
mysql 基础命令集
awk 命令详解
Centos6.3编译安装nginx+php步骤
OCR （Optical Character Recognition，光学字符识别）
每日归档
更多
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022