大家先回顾一下C语言里面的宏，如果写一个Add的宏，最后一种才是正确的，这就证明了宏是不好控制的，因为运算符的优先级的原因等等，所以宏就有一些缺点：
?1、容易出错，语法细节多
?2、不能调试
?3、没有类型安全的检查
那么 就可以使用enum const inline 替代宏
?enum const -> 宏常量
?inline ->宏函数
宏函数的优点就是不用建立栈帧，提高效率。那么inline内联函数拥有宏函数的优点，还避免了它的缺点，可以调试，而且没那么多的语法细节。
//#define ADD(int x, int y) return x + y;
//#define ADD(x, y) return x + y;
//#define ADD(x, y) x + y;
//#define ADD(x, y) (x + y)
//#define ADD(x, y) (x) + (y)
//#define ADD(x, y) ((x) + (y));
#define ADD(x, y) ((x) + (y))以inline修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开，没有函数调 用建立栈帧的开销，内联函数提升程序运行的效率。
#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","梨"} };
Map::iterator it = m.begin();
while (it != m.end())
{
//....
}
return 0;
}typedef char* pstring;
int main()
{
const pstring p1; ? ?// 编译成功还是失败？
const pstring* p2; ? // 编译成功还是失败？
return 0;
}在早期C/C++中auto的含义是：使用auto修饰的变量，是具有自动存储器的局部变量，但遗憾的 是一直没有人去使用它，大家可思考下为什么？
C++11中，标准委员会赋予了auto全新的含义即：auto不再是一个存储类型指示符，而是作为一 个新的类型指示符来指示编译器，auto声明的变量必须由编译器在编译时期推导而得。
#include <string>
#include <map>
typedef std::map<std::string, std::string> Map;
int main()
{
Map m{ { "apple", "苹果" },{ "orange", "橙子" }, {"pear","梨"} };
Map::iterator it = m.begin();
while (it != m.end())
{
//....
}
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;
}1. auto与指针和引用结合起来使用 用auto声明指针类型时，用auto和auto*没有任何区别，但用auto声明引用类型时则必须加&。
int main()
{
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的初始化表达式类型不同
}1. auto不能作为函数的参数
// 此处代码编译失败，auto不能作为形参类型，因为编译器无法对a的实际类型进行推导
void TestAuto(auto a)
{}void TestAuto()
{
? ?int a[] = {1,2,3};
? ?auto b[] = {4，5，6};
}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;
}void TestFor()
{
int array[] = { 1, 2, 3, 4, 5 };
for(auto& e : array)
? ? e *= 2;
for(auto e : array)
? ? cout << e << " ";
return 0;
}1. for循环迭代的范围必须是确定的 对于数组而言，就是数组中第一个元素和最后一个元素的范围；对于类而言，应该提供 begin和end的方法，begin和end就是for循环迭代的范围。 注意：以下代码就有问题，因为for的范围不确定：
void TestFor(int array[])
{
? ?for(auto& e : array)
? ? ? ?cout<< e <<endl;
}void TestPtr()
{
int* p1 = NULL;
int* p2 = 0;
// ……
}#ifndef NULL
#ifdef __cplusplus
#define NULL ? 0
#else
#define NULL ? ((void *)0)
#endif
#endifvoid f(int)
{
cout<<"f(int)"<<endl;
}
void f(int*)
{
cout<<"f(int*)"<<endl;
}
int main()
{
f(0);
f(NULL);
f((int*)NULL);
return 0;
}注意：1. 在使用 nullptr 表示指针空值时，不需要包含头文件，因为 nullptr 是 C++11 作为新关键字引入 的 。2. 在 C++11 中， sizeof(nullptr) 与 sizeof((void*)0) 所占的字节数相同。3. 为了提高代码的健壮性，在后续表示指针空值时建议最好使用 nullptr 。
今天的分享到这里就结束了，感谢大家的阅读！?