c++
引用和指针的区别
#include<iostream>
using namespace std;
int main()
{
int a = 0;
int* p1 = &a; //指针是要开空间的,在32位系统下是4个字节,64位是8个字节
int& ref = a; //引用是不用开空间的,它只是a的一个别名,它和a共用一个空间,但是引用是靠指针来实现的,所以引用的底层就是指针
return 0;
看一看它们的汇编代码
你会发现:指针和引用在底层是一模一样的;
引用和指针的不同点:
- 引用概念上定义一个变量的别名,指针存储一个变量地址。
- 引用在定义时必须初始化,指针没有要求
- 引用在初始化时引用一个实体后,就不能再引用其他实体,而指针可以在任何时候指向任何
一个同类型实体 - 没有NULL引用,但有NULL指针
- 在sizeof中含义不同:引用结果为引用类型的大小,但指针始终是地址空间所占字节个数(32
位平台下占4个字节) - 引用自加即引用的实体增加1,指针自加即指针向后偏移一个类型的大小
- 有多级指针,但是没有多级引用
- 访问实体方式不同,指针需要显式解引用,引用编译器自己处理
- 引用比指针使用起来相对更安全
内联函数
为啥c++要有内联函数?
为了弥补c语言宏的缺点
宏有哪些缺点
首先,宏分为两种:1.宏常量,2. 宏函数
//宏常量
#define N 10
//宏函数
#define Add(x,y) ((x) + (y))
缺点:
- 容易出错,语法的坑有很多
- 不能调试,(在预处理阶段就替换掉了)
- 没有类型安全的检查
优点: - 没有类型的严格限制
- 针对频繁调用的小函数,不用去建立函数栈帧,提高了效率
为了继续享用宏的优点并规避掉宏的缺点,c++提出了内联函数
所以,啥是内联函数?
概念:
以inline修饰的函数叫做内联函数,编译时C++编译器会在调用内联函数的地方展开,没有函数调
用建立栈帧的开销,内联函数提升程序运行的效率
内联函数没有调用的消耗, 会在它被调用的地方展开,所以内联也不会建立函数栈帧
既然内联函数这么香,那我们可不可以把所有的函数都搞成内联函数?
注意:是不可以的,因为会造成代码臃肿,内联不建立函数栈帧,直接在你调用的那个地方展开,
如果是比较短小的函数还行,但是如果是一个比较大的函数,比如这个函数有100行代码,你又再程序中调用了100次,那么如果直接在调用的地方展开的话,会直接增加:100*100 = 10000 行代码。
所以:
c++的编译器再看到你使用内联函数时会判断:如果你写的函数很大或是个递归,它就会直接忽略掉内联,转而用普通函数的方式来处理这个。
虽然内联很爽,但是内联函数也有一个坑:声明和定义不能分离
这里指的是:分离和定义不能分离在两个不同的文件中 ,不然会出现链接错误
auto 关键字
1 类型别名思考
随着程序越来越复杂,程序中用到的类型也越来越复杂,经常体现在:
- 类型难于拼写
- 含义不明确导致容易出错
std::map<std::string, std::string>::iterator
是一个类型,但是该类型太长了,特别容
易写错。聪明的同学可能已经想到:可以通过typedef给类型取别名,比如:
#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;
}
#include <string>
#include <map>
typedef std::map<std::string, std::string> Map;
int main()
{
Map m{ { "apple", "苹果" },{ "orange", "橙子" }, {"pear","梨"} };
使用typedef给类型取别名确实可以简化代码,但是typedef有会遇到新的难题:
在编程时,常常需要把表达式的值赋值给变量,这就要求在声明变量的时候清楚地知道表达式的
类型。然而有时候要做到这点并非那么容易,因此C++11给auto赋予了新的含义。
auto简介
在早期C/C++中auto的含义是:使用auto修饰的变量,是具有自动存储器的局部变量,但遗憾的
是一直没有人去使用它,大家可思考下为什么?
C++11中,标准委员会赋予了auto全新的含义即:auto不再是一个存储类型指示符,而是作为一
个新的类型指示符来指示编译器,auto声明的变量必须由编译器在编译时期推导而得。
【注意】
使用auto定义变量时必须对其进行初始化,在编译阶段编译器需要根据初始化表达式来推导auto
的实际类型。因此auto并非是一种“类型”的声明,而是一个类型声明时的“占位符”,编译器在编
译期会将auto替换为变量实际的类型。
Map::iterator it = m.begin();
while (it != m.end())
{
//....
}
return 0;
}
typedef char* pstring;
int main()
{
const pstring p1; // 编译成功还是失败?
const pstring* p2; // 编译成功还是失败?
return 0;
}
int TestAuto()
{
return 10;
}
int main()
{
int a = 10;
auto b = a;
auto c = 'a';
auto d = TestAuto();
cout << typeid(b).name() << endl;
cout << typeid(c).name() << endl;
cout << typeid(d).name() << endl;
//auto e; 无法通过编译,使用auto定义变量时必须对其进行初始化
return 0;
}
auto的使用细则
1. auto与指针和引用结合起来使用
用auto声明指针类型时,用auto和auto*没有任何区别,但用auto声明引用类型时则必须
加&
{
int x = 10;
auto a = &x;
auto* b = &x;
auto& c = x;
cout << typeid(a).name() << endl;
cout << typeid(b).name() << endl;
cout << typeid(c).name() << endl;
*a = 20;
*b = 30;
c = 40;
return 0;
}
2. 在同一行定义多个变量
当在同一行声明多个变量时,这些变量必须是相同的类型,否则编译器将会报错,因为编译
器实际只对第一个类型进行推导,然后用推导出来的类型定义其他变量。
void TestAuto()
{
auto a = 1, b = 2;
auto c = 3, d = 4.0; // 该行代码会编译失败,因为c和d的初始化表达式类型不同
}
auto不能推导的场景
1. auto不能作为函数的参数
// 此处代码编译失败,auto不能作为形参类型,因为编译器无法对a的实际类型进行推导
void TestAuto(auto a)
{}
2. auto不能直接用来声明数组
void TestAuto()
{
int a[] = {1,2,3};
auto b[] = {4,5,6};
}
3. 为了避免与C++98中的auto发生混淆,C++11只保留了auto作为类型指示符的用法
4. auto在实际中最常见的优势用法就是跟以后会讲到的C++11提供的新式for循环,还有
lambda表达式等进行配合使用
其他:
c++中可以用一个关键字来判断某个变量的类型:
这个关键字就是:typeid
int d = 1;
auto e = &d;
cout << typeid(d).name() << endl;
cout << typeid(e).name() << endl;
范围for
#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;
int main()
{
//学习 范围for
//定义一个数组
int array[] = { 1, 2, 3, 4, 5 };
//学习范围for之前,我们是这样访问数组的
for (int i = 0; i < sizeof(array) / sizeof(array[0]); i++)
{
array[i] *= 2;
}
//打印这个数组
for (int i = 0; i < sizeof(array) / sizeof(array[0]); i++)
{
cout << array[i] << " ";
}
cout << endl;
//学习范围for之后,我们可以这样访问数组
for (auto e : array) //1. 他会依次取数组中的数据赋值给e 2. 自动判断结束 3. 并自动迭代
{
//直接打印
cout << e << " ";
}
cout << endl;
return 0;
}
注意以下情况:
#include<iostream>
using namespace std;
int main()
{
int array[] = { 1, 2, 3, 4, 5 };
for (auto x : array)
{
x *= 2; //为啥 我在这里乘以了 2 ,但是打印的结果却还是原来的值;
}
for (auto x : array)
{
cout << x << " ";
}
cout << endl;
return 0;
}
这个范围for它取值,它是将这个数组里面的值取出来依次赋值给x,就比如他把array[0]取出来,赋值给x之后,再把array[1]取出来赋值给x,依次下去再把array[2]复制给array[3]复制给x。
所以你改变x的值,你并不能影响数组原来当中的值。
那如何才能改变原来数组中的值呢?
很简单:我们把引用加上就好了
#include<iostream>
using namespace std;
int main()
{
int array[] = { 1, 2, 3, 4, 5 };
for (auto& x : array) //在这里把引用加上
{
x *= 2;
}
for (auto x : array)
{
cout << x << " ";
}
cout << endl;
return 0;
}
给了&
引用之后,x 就相当于是array1,array2…的别名了,所以 修改 x 就可以修改 array 数组了
注意这种情况只能用&
引用,不能用 指针,如果用指针会造成语法错误,没法编译通过。
还有一件事,请判断,下面这种写法能行吗?
#include<iostream>
using namespace std;
void test_for(int array[])
{
for (auto& x : array)
{
cout << array[x] << " ";
}
}
int main()
{
int array[] = { 1, 2, 3, 4, 5 };
return 0;
}
所以这种写法是不行的。