初识C++ · 入门(2)

最新推荐文章于 2024-05-22 09:22:48 发布

XY.散人

最新推荐文章于 2024-05-22 09:22:48 发布

阅读量890

点赞数 9

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

本文链接：https://blog.csdn.net/2301_79697943/article/details/137206682

版权

1 引用

1.1引用的概念

人有外号，程序中的变量也可以有，不懂二级指针的人有福了，祖师爷在加小语法的时候觉得使用二级指针太麻烦了，索性加入引用的概念，也就是给成员变量取别名，该别名和成员变量共用一块空间，就像李逵外号黑旋风一样，使用方式是类型后面加个&：

int main()
{
	int a = 1;
	int& b = a;
	cout << a << ' ' << b;
	return 0;
}

这个时候b就是a，我们对b进行修改的同时也会修改a。

1.2 引用的特性

外号可以有一个，也可以有多个，所以：

int main()
{
	int a = 1;
	int& b = a;
	int& c = b;
	int& d = c;
	cout << a << b << c << d;
	return 0;
}

对一个变量取多个“外号”也是没有问题的，但是引用一旦成立，该引用类型就不能再去引用其他元素，就像黑旋风不能是浪里白条一样。

int main()
{
	int a = 1,c = 1;
	int& b = a;
	int& b = c;
	return 0;
}

此时代码就会报错，因为b重定义了。

引用的时候一定要初始化，不然就像是先选个外号，看谁像这个外号再给谁按上去，这是不行的，所以引用之前一定要初始化：

int& a;

这种就是错误的代码，没有引用实体。

我们在引用的时候还要避免一个问题——权限放大。

int main()
{
	const int a = 1;
	int& b = a;
	int c = a;
	return 0;
}

int c = a这行代码是无误的，赋值是没有问题的，但是int& b这行代码就有问题了，

因为a被const修饰了，所以a不能被修改，但是引用类型是int&，就代表可以被修改，所以这里存在权限放大的问题，解决方法就是:

int main()
{
    const int a = 1;
    const int& b = a;
    return 0;
}

引用类型和引用实体保持一致就行，就不会存在权限放大的问题，引用的实现我们就需要保证一个点：引用类型和引用实体是一个级别。那么有人问了，权限放大了不行，权限缩小会怎么样？

int main()
{
    int a = 1;
    const int& b = a;
    return 0;
}

是没有问题的，代码编译也都跑得过去，所以权限缩小是可以的。

权限放大看着是很好理解的，那么这段代码呢：

int main()
{
	int a = 1, b = 1;
	int& x = a + b;
	return 0;
}

a + b的结果是int没错吧？那么可不可以用int&来引用呢？实际上是不可以的，因为a + b是一个常值，就跟被const修饰了一样，所以要引用只能加一个const。

int main()
{    
    double d = 12.34;
    const int& i = d;
    return 0;
}

如果存在类型转化，但是用了const修饰，也是可以引用的。这是因为类型转换的时候存在一个临时变量，这个临时变量是常性的，所以用了const修饰才能引用。

2 传值，传引用的效率

引用被发明来就是为了省事的，比如单链表的实现那里，二级指针是哪里都有，那么有了引用，原来的参数即写法就会省下一大半的时间：

void SLTNode(Node** pphead, int val);
void SLTNode(Node*& head, int val);

有了引用就不用考虑二级指针越界访问等问题了，也没有解引用的问题了，是非常方便的。

我们可以认为，传引用就是传我们要修改的那个元素进去：

void swap(int& x, int& y)
{
	int tem = x;
	x = y;
	y = tem;
}
int main()
{
	int a = 1, b = 2;
	swap(a, b);
	cout << a << " " << b;
	return 0;
}

最后是可以成功交换a 和 b 的值的，我们就不用单独使用指针了，

实现某些功能的时候我们传值也可以，传引用也可以，具体哪个的效率高呢？函数在接收参数或者返回参数的时候，传值都是进行临时的拷贝，数据量一旦大了起来，效率是十分低下的：

struct A
{
	int arr[10000];
};
void Test1(A a)
{}
void Test2(A& a)
{}
int main()
{
	A a;
	size_t begin1 = clock();
	for (size_t i = 0; i < 10000; i++)
		Test1(a);
	size_t end1 = clock();

	size_t begin2 = clock();
	for (size_t i = 0; i < 10000; i++)
		Test2(a);
	size_t end2 = clock();

	cout << "Test1-time: " << end1 - begin1 << endl;
	cout << "Test2-time: " << end2 - begin2<< endl;

	return 0;
}

我们创建一个结构体，成员变量是40000个字节的一个数组，那么如果我们传值调用，如Test1，用一个40000字节的数组去拷贝实参，效率很低下，如果我们传引用的话，就相当于我们直接对arr数组进行修改，没有单独开辟一块空间去拷贝，效率自然就高了起来。使用时间函数来对比一下就知道了：

因为Test2的时间太短了，小于1ms，所以打印出来的结果是0。

struct A
{
	int arr[10000];
}a;
A Test1()
{
	return a;
}
A& Test2()
{
	return a;
}

int main()
{
	
	size_t begin1 = clock();
	for (size_t i = 0; i < 10000; i++)
		Test1();
	size_t end1 = clock();

	size_t begin2 = clock();
	for (size_t i = 0; i < 10000; i++)
		Test2();
	size_t end2 = clock();

	cout << "Test1-time: " << end1 - begin1 << endl;
	cout << "Test2-time: " << end2 - begin2<< endl;

	return 0;
}

返回值也是一样的道理，如果我返回的是一个值，那么返回的就是一份临时拷贝，效率是十分低下的：

3 引用和指针的区别

从语法上看，引用和被引用的对象共用一块空间：

int main()
{
	int a = 1;
	int& ra = a;
	cout << &a << endl;
	cout << &ra << endl;
	return 0;
}

打印出来的地址也是一样的。

如果从汇编代码看，底层来讲，引用也是有自己的独立空间的：

结合使用了指针的汇编来看的话，它们的底层实现是一样的，所以引用实际上也是开辟了空间的。

实际上引用和指针的区别是比较大的，这里就列举几点比较重要的：
1·引用在定义时必须初始化，指针没有要求

2· 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体

3·没有NULL引用，但有NULL指针

4·有多级指针，但是没有多级引用

5·引用比指针使用起来相对更安全

6·访问实体方式不同，指针需要显式解引用，引用编译器自己处理

4 内联函数

4.1 内联函数的定义

内联函数是被inline修饰的函数，使用频繁且代码量小的情况下会使用内联函数，实际上就是一种空间换取时间的做法，因为编译期间会在函数处将函数代码展开，有点像预处理期间的头文件展开，那么为什么是空间换时间呢？
因为函数展开了就相当于把一段代码放过去，没有单独的函数栈帧开销，所以时间上会省事，但是因为代码量的增加，所以生成的可执行文件占用的存储空间是会变大的，一旦内联函数的代码量大了一点，频繁使用之后可执行程序的内存大小加的可不是一点，所以要求内联函数的代码量是少量代码。

int Add(int x,int y)
{
	return x + y;
}

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

我们知道call一个函数，就是给函数一个地址，并给它开辟函数栈帧，那么没有被inline修饰之前是有call的，在被inline修饰之后：

inline int Add(int x,int y)
{
	return x + y;
}

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

发现Add那里没有call对应的汇编代码，在release模式下我们只需要看有没有call就行，在debug模式下我们要进行相应的设置：

要在这两个地方修改：

可以看到依旧是没有关于call的汇编代码，直接就相加了，这就是内联函数空间换取时间的做法。

那儿有人不解，编译阶段代码展开，不就类似于宏定义吗，直接定义一个宏难道不香吗？

对于宏，宏有时候确实是方便的，但是实现复杂的功能的时候，宏有时候非常抽象，更重要的一点是宏不能调试，在括号等小细节上容易出错，也没有类型检查，所以该使用内联函数的时候还是使用内联函数吧!

4. 2 内联函数的特性

虽然内联函数是空间换时间的，但是实现的时候还得看编译器，不同编译器关于inline的实现机制可能不同，一般来说将函数规模较小，不是递归，频繁调用的函数采用inline修饰。

在C++Prime第五版中关于内联函数是这样建议的：

内联函数不建议分离和定义分离，这样会导致链接的时候找不到函数的地址：

// F.h
#include <iostream>
using namespace std;
inline void Func(int i);
// F.cpp
#include "F.h"
void Func(int i)
{
 cout << i << endl;
}
// main.cpp
#include "F.h"
int main()
{
 Func(10);
 return 0;
}

5 关键字auto

5.1关于命名的思考

学习auto之前，我们思考一个问题，就是随着程序的复杂程度，命名也变成了一个难点，命名长的时候体现在类型名难于拼写，含义不够明确。

如下代码：

#include <string>
#include <map>
int main()
{
 std::map<std::string, std::string> m{ { "apple", "苹果" }, { "orange", 
"橙子" }, 
   {"pear","梨"} };
 std::map<std::string, std::string>::iterator it = m.begin();
 while (it != m.end())
 {
 //....
 }
 return 0;
}

std::map::iterator ，std::string>::iterator是一个类型，难于拼写的同时含义还不够明确，那么typedef可以解决吗？typedef 可以解决一些命名问题，但是碰到这种就哦豁了：

typedef char* pc;
int main()
{
	const pc p1;
	const pc* p2;
	return 0;
}

p1是会报错的，因为const修饰是指针本身，代码可以理解为char* const p1,那么const修饰的指针是要初始化的，第二个不报错因为可以理解成const char* p2，修饰的是指向的对象可以不用进行初始化，所以第一个会报错。

即有时候赋值给变量是含义不明确的，所以委员会给了auto一个新含义。

5.2 关于auto的发展

C++11中，标准委员会赋予了auto全新的含义即：auto不再是一个存储类型指示符，而是作为一个新的类型指示符来指示编译器，auto声明的变量必须由编译器在编译时期推导而得。

简单理解来说就是auto可以用来自动推导变量类型：

typedef char* pc;
int main()
{
	int a = 1;
	auto b = a;
	auto c = 12.34;
	cout << typeid(a).name() << endl;
	cout << typeid(b).name() << endl;
	cout << typeid(c).name() << endl;
	return 0;
}

这里介绍一个关键字typeid，用法记住就行，用来判断变量的类型的，打印出来的结果就是int int double。

就和引用一样，auto修饰变量的时候也要初始化，不初始化它哪里知道变量是什么类型的呢?

5.3 auto使用规则

auto修饰指针的时候有两种修饰方法：

int main()
{
	int a = 1,b = 1;
	auto pa = &a;
	auto* pb = &b;
}

auto后面加不加*都是可以的。

但是auto修饰引用类型的时候&是一定要加的：

int main()
{
	int a = 1;
	auto& pa = a;
}

当auto修饰多个变量的时候，如果类型不同也是不可以的：

	auto b = 1, c = 2.3;

这时候会报错，因为初始化类型不同。

auto有两个不能推导的情况：

1 auto不能用于充当函数参数

这就有点像auto修饰的变量没有初始化，所以会报错

int Add(auto x)
{
	return 1;
}

2 auto不能用于修饰数组

int main()
{
	auto arr[10] = { 0 };
	return 0;
}

6 范围for的使用

在C语言里面，我们遍历一个数组通常采用for的方式：

int main()
{
	int arr[10] = { 0 };
	for (int i = 0; i < 10; i++)
	{
		;
	}
	return 0;
}

在C++里面，对于一个有确定范围的循环，是可以使用范围for的，省时省力：
for循环后的括号由冒号“ ：”分为两部分：第一部分是范围内用于迭代的变量，第二部分则表示被迭代的范围。

int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,0 };
	for (auto a : arr)
	{
		cout << a << " ";
	}
	return 0;
}

这时候auto的妙用就出来了，可以自动识别类型。

这段代码的意思就是自动遍历数组arr，将数组里面的元素依次放到a里面，所以a是一个用来接收数组元素的一个临时变量，打印的时候打印的就是a，所以数组里面的元素是没有被修改的，想要修改，那么引用类型就可以：

int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,0 };
	for (auto& a : arr)
	{
		a *= 2;
	}
	for (auto a : arr)
	{
		cout << a << ' ';
	}
	return 0;
}

但是范围for的话只能用于从0开始遍历，不能从某个地方开始遍历或者是倒着遍历，而且要求遍历的时候范围是可以确定的，也就是说数组类型int arr[m]的m一定是一个确定的值。

其余和普通循环无异，continue或者是break都可以正常使用。

7 空指针

NULL实际上是一个宏。

定义中表明NULL被宏定义为0或者是0强转的泛型指针，所以有时候使用空指针的时候不免会出现问题：

void Func(int)
{
	cout << "int" << endl;
}
void Func(int*)
{
	cout << "int*" << endl;
}
int main()
{
	Func(0);
	Func(NULL);
	Func((int*)NULL);
}

程序原本传NULL是为了访问int*的函数的，但是因为NULL被定义为0，所以打印出来的是int，所以要强转为(int*)才能访问第二个函数。

在C++11中为了区分开来，关键字nullptr表示空指针。

在C++11中，sizeof(nullptr) 与 sizeof((void*)0)所占的字节数相同。

以上就是C到C++引入的一些小语法，感谢阅读！

XY.散人

关注

9
点赞
踩
30

收藏

觉得还不错? 一键收藏
0
评论
初识C++ · 入门(2)

内联函数是被inline修饰的函数，使用频繁且代码量小的情况下会使用内联函数，实际上就是一种空间换取时间的做法，因为编译期间会在函数处将函数代码展开，有点像预处理期间的头文件展开，那么为什么是空间换时间呢？因为函数展开了就相当于把一段代码放过去，没有单独的函数栈帧开销，所以时间上会省事，但是因为代码量的增加，所以生成的可执行文件占用的存储空间是会变大的，一旦内联函数的代码量大了一点，频繁使用之后可执行程序的内存大小加的可不是一点，所以要求内联函数的代码量是少量代码。int main()
复制链接

扫一扫