C++入门（二）

内联函数

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

#define Fun(x,y) x*y
#define N 10
int Mul(int x, int y) {
	return x*y;
}
int main() {
	cout << Fun(2, 3) << endl;
	cout << 2 * 3 << endl;
	cout << Mul(2, 3) << endl;//call Mull(首行地址)
	return 0;
}
//define定义的宏是不需要调用的，而函数Mul需要调用

 注意：

1. inline是一种以空间换时间的做法，省去调用函数额开销。所以代码很长或者有循环/递归的 函数不适宜使用作为内联函数。

2. inline对于编译器而言只是一个建议，编译器会自动优化，如果定义为inline的函数体内有循 环/递归等等，编译器优化时会忽略掉内联。

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

如何查看内联函数呢？我们用vs转到 反汇编，没有call就说明是内联函数

宏的优缺点：

 优点：

1.增强代码的复用性。

2.提高性能。 

缺点：

1.不方便调试宏。（因为预编译阶段进行了替换）          

2.导致代码可读性差，可维护性差，容易误用。 

3.没有类型安全的检查 。 

 例1：

#define Fun(x,y) x*y
int main() {
	cout << Fun(2 + 3, 4) << endl;
	return 0;
}
//输出
//14

为什么会输出14呢 应为宏只是简单的替换

上题中：2+3与4 被替换为 2+3*4，所以结果自然是14，而不是我们想要的20

这就很好的说明了宏没有安全检查类型

那么应该如何修改呢？

例2 

#define Fun(x,y) (x)*(y)
int main() {
	cout << Fun(2 + 3, 4) << endl;
	return 0;
}
//输出
//20

C++有哪些技术替代宏？

1. 常量定义 换用const  

2. 函数定义 换用内联函数  

auto关键字

auto不再是一个存储类型指示符，而是作为一 个新的类型指示符来指示编译器，auto声明的变量必须由编译器在编译时期推导而得。

例3 

typeid(变量).name()  输出变量类型

int main() {
	auto a = 1;
	auto b = 'c';
	auto c = 1.1;
	cout << typeid(a).name() << endl;
	cout << typeid(b).name() << endl;
	cout << typeid(c).name() << endl;
}
//输出
//int
//char
//double

auto可以根据一个变量的值自动地来给它定一个类型

 auto的使用

1. auto与指针和引用结合起来使用时。

用auto声明指针类型时，用auto和auto*没有任何区别，但用auto声明引用类型时则必须加&

2.当在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器将会报错，因为编译器实 际只对第一个类型进行推导，然后用推导出来的类型定义其他变量。

3.auto不能直接用来声明数组

4.auto不能作为函数的参数

 例4

int main() {
	auto a = 3;
	auto p = &a;
	auto* ptr = &a;//指针这两种写法都行
	auto ra = a;
	auto& rra = a;//引用必须要打&
	cout << typeid(p).name()<< endl;
	cout << typeid(ptr).name() << endl;
	cout << typeid(rra).name() << endl;
	cout << typeid(ra).name() << endl;
}
//输出
//int*
//int*
//int
//int

例5 三种错误应用auto的示例

int main() {
	auto a = 3, b = 2;
	auto c = 3, d = 2.2;//vs报错：对于此实体“auto”类型是 "double"，但之前默示为 "int"
}

int main() {
	auto arr[3] = { 1,2,3 };//vs报错：“auto”类型不能出现在顶级数组类型中
}

void test(auto a) {//vs报错：此处不允许使用auto

}

 基于范围的for循环

for循环后的括号由冒号“  ：”分为两部分：第一部分是范 围内用于迭代的变量，第二部分则表示被迭代的范围。

例6 

int main() {
	int arr[] = { 1,2,3,4,5 };
	for (int e : arr)
		cout << e << endl;//数组范围是确定的
	return 0;
}
//输出
//1
//2
//3
//4
//5

例8 一种错误的写法

void test(int arr[]) {
	for (int e : arr)//vs报错：此基于范围的“for”语句需要适合的 "begin" 函数，但未找到
		cout << e << endl;
}
int main() {
	int arr[] = { 1,2,3,4,5 };
	test(arr);
	return 0;
}
//函数中arr仅仅是arr[]数组的首地址，没有了范围

注意：与普通循环类似，可以用continue来结束本次循环，也可以用break来跳出整个循环。
 

基于范围的for循环使用条件

 1. for循环迭代的范围必须是确定的 对于数组而言，就是数组中第一个元素和后一个元素的范围；对于类而言，应该提供begin和 end的方法，begin和end就是for循环迭代的范围。

2. 迭代的对象要实现++和==的操作。

 指针空值nullptr

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

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

现在我们可以初始化指针： 

int main() {
	int* a = nullptr;
	int b = nullptr;//vs报错："std::nullptr_t" 类型的值不能用于初始化 "int" 类型的实体	
}

int main() {
	int* ptr = nullptr;
	cout << typeid(nullptr).name() << endl;
	cout << typeid(ptr).name() << endl;
}
//输出：
//std::nullptr_t
//int*

我们可看到：

nullptr类型是nullptr_t

通过隐式类型转换转变为int*

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。

注意：
1. 在使用nullptr表示指针空值时，不需要包含头文件，因为nullptr是C++11作为新关键字引入 的。

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

3. 为了提高代码的健壮性，在后续表示指针空值时建议好使用nullptr