const 关键字：
作用：
-
修饰变量，说明该变量不可以被改变； -
修饰指针，分为指向常量的指针和指针常量； -
常量引用，经常用于形参类型，即避免了拷贝，又避免了函数对值的修改； -
修饰成员函数，说明该成员函数内不能修改成员变量。
// 类A
class A
{
private:
const int a; // 常对象成员，只能在初始化列表赋值
public:
// 构造函数
A() { };
A(int x) : a(x) { }; // 初始化列表
// const可用于对重载函数的区分
int getValue(); // 普通成员函数
int getValue() const; // 常成员函数，不得修改类中的任何数据成员的值
};
void function()
{
// 对象
A b; // 普通对象，可以调用全部成员函数
const A a; // 常对象，只能调用常成员函数、更新常成员变量
const A *p = &a; // 常指针
const A &q = a; // 常引用
// 指针
char greeting[] = "Hello";
char* p1 = greeting; // 指针变量，指向字符数组变量
const char* p2 = greeting; // 指针变量，指向字符数组常量
char* const p3 = greeting; // 常指针，指向字符数组变量
const char* const p4 = greeting; // 常指针，指向字符数组常量
}
// 函数
void function1(const int Var); // 传递过来的参数在函数内不可变
void function2(const char* Var); // 参数指针所指内容为常量
void function3(char* const Var); // 参数指针为常指针
void function4(const int& Var); // 引用参数在函数内为常量
// 函数返回值
const int function5(); // 返回一个常数
const int* function6(); // 返回一个指向常量的指针变量，使用：const int *p = function6();
int* const function7(); // 返回一个指向变量的常指针，使用：int* const p = function7();
=================================================================
static关键字
作用：
-
修饰普通变量，修改变量的存储区域和生命周期，使变量存储在静态区，在 main 函数运行前就分配了空间，如果有初始值就用初始值初始化它，如果没有初始值系统用默认值初始化它。 -
修饰普通函数，表明函数的作用范围，仅在定义该函数的文件内才能使用。在多人开发项目时，为了防止与他人命令函数重名，可以将函数定位为 static。 -
修饰成员变量，修饰成员变量使所有的对象只保存一个该变量，而且不需要生成对象就可以访问该成员。 -
修饰成员函数，修饰成员函数使得不需要生成对象就可以访问该函数，但是在 static 函数内不能访问非静态成员。
=================================================================
this 指针
-
this?指针是一个隐含于每一个非静态成员函数中的特殊指针。它指向正在被该成员函数操作的那个对象。
-
当对一个对象调用成员函数时，编译程序先将对象的地址赋给?this?指针，然后调用成员函数，每次成员函数存取数据成员时，由隐含使用?this?指针。 -
当一个成员函数被调用时，自动向它传递一个隐含的参数，该参数是一个指向这个成员函数所在的对象的指针。 -
this?指针被隐含地声明为:?ClassName?const this`，这意味着不能给 `this` 指针赋值；在 `ClassName` 类的 `const` 成员函数中，`this` 指针的类型为：`const ClassName?const，这说明不能对?this?指针所指向的这种对象是不可修改的（即不能对这种对象的数据成员进行赋值操作）；
-
this?并不是一个常规变量，而是个右值，所以不能取得?this?的地址（不能?&this）。
-
在以下场景中，经常需要显式引用?this?指针：
-
为实现对象的链式引用； -
为避免对同一对象进行赋值操作； -
在实现一些数据结构时，如 `list`。
=================================================================
inline 内联函数
特征
-
相当于把内联函数里面的内容写在调用内联函数处； -
相当于不用执行进入函数的步骤，直接执行函数体； -
相当于宏，却比宏多了类型检查，真正具有函数特性； -
不能包含循环、递归、switch 等复杂操作； -
在类声明中定义的函数，除了虚函数的其他函数都会自动隐式地当成内联函数。 // 声明1（加 inline，建议使用）
inline int functionName(int first, int secend,...);
// 声明2（不加 inline）
int functionName(int first, int secend,...);
// 定义
inline int functionName(int first, int secend,...) {/****/};
// 类内定义，隐式内联
class A {
int doA() { return 0; } // 隐式内联
}
// 类外定义，需要显式内联
class A {
int doA();
}
inline int A::doA() { return 0; } // 需要显式内联
编译器对 inline 函数的处理步骤： -
将 inline 函数体复制到 inline 函数调用点处； -
为所用 inline 函数中的局部变量分配内存空间； -
将 inline 函数的的输入参数和返回值映射到调用方法的局部变量空间中； -
如果 inline 函数有多个返回点，将其转变为 inline 函数代码块末尾的分支（使用 GOTO）。
优缺点：
优点：
-
内联函数同宏函数一样将在被调用处进行代码展开，省去了参数压栈、栈帧开辟与回收，结果返回等，从而提高程序运行速度。 -
内联函数相比宏函数来说，在代码展开时，会做安全检查或自动类型转换（同普通函数），而宏定义则不会。 -
在类中声明同时定义的成员函数，自动转化为内联函数，因此内联函数可以访问类的成员变量，宏定义则不能。 -
内联函数在运行时可调试，而宏定义不可以。
缺点：
-
代码膨胀。内联是以代码膨胀（复制）为代价，消除函数调用带来的开销。如果执行函数体内代码的时间，相比于函数调用的开销较大，那么效率的收获会很少。另一方面，每一处内联函数的调用都要复制代码，将使程序的总代码量增大，消耗更多的内存空间。 -
inline 函数无法随着函数库升级而升级。inline函数的改变需要重新编译，不像 non-inline 可以直接链接。 -
是否内联，程序员不可控。内联函数只是对编译器的建议，是否对函数内联，决定权在于编译器。
=========================================================================
虚函数：
定义一个函数为虚函数，不代表函数为不被实现的函数。
定义他为虚函数是为了允许用基类的指针来调用子类的这个函数。
定义一个函数为纯虚函数，才代表函数没有被实现。
定义纯虚函数是为了实现一个接口，起到一个规范的作用，规范继承这个类的程序员必须实现这个函数。
class A
{
public:
virtual void foo()
{
cout<<"A::foo() is called"<<endl;
}
};
class B:public A
{
public:
void foo()
{
cout<<"B::foo() is called"<<endl;
}
};
int main(void)
{
A *a = new B();
a->foo(); // 在这里，a虽然是指向A的指针，但是被调用的函数(foo)却是B的!
return 0;
}
这个例子是虚函数的一个典型应用，通过这个例子，也许你就对虚函数有了一些概念。它虚就虚在所谓"推迟联编"或者"动态联编"上，一个类函数的调用并不是在编译时刻被确定的，而是在运行时刻被确定的。由于编写代码的时候并不能确定被调用的是基类的函数还是哪个派生类的函数，所以被成为"虚"函数。
=========================================================================
虚函数（virtual）可以是内联函数（inline）吗？
1、虚函数可以是内联函数，内联是可以修饰虚函数的，但是当虚函数表现多态性的时候不能内联。
2、内联是在编译器建议编译器内联，而虚函数的多态性在运行期，编译器无法知道运行期调用哪个代码，因此虚函数表现为多态性时（运行期）不可以内联。
3、inline virtual?唯一可以内联的时候是：编译器知道所调用的对象是哪个类（如?Base::who()），这只有在编译器具有实际对象而不是对象的指针或引用时才会发生。
虚函数内联使用：
#include <iostream>
using namespace std;
class Base
{
public:
inline virtual void who()
{
cout << "I am Base\n";
}
virtual ~Base() {}
};
class Derived : public Base
{
public:
inline void who() // 不写inline时隐式内联
{
cout << "I am Derived\n";
}
};
int main()
{
// 此处的虚函数 who()，是通过类（Base）的具体对象（b）来调用的，编译期间就能确定了，所以它可以是内联的，但最终是否内联取决于编译器。
Base b;
b.who();
// 此处的虚函数是通过指针调用的，呈现多态性，需要在运行时期间才能确定，所以不能为内联。
Base *ptr = new Derived();
ptr->who();
// 因为Base有虚析构函数（virtual ~Base() {}），所以 delete 时，会先调用派生类（Derived）析构函数，再调用基类（Base）析构函数，防止内存泄漏。
delete ptr;
ptr = nullptr;
system("pause");
return 0;
}
=========================================================================
assert()
断言，是宏，而非函数。assert 宏的原型定义在?<assert.h>（C）、<cassert>（C++）中，其作用是如果它的条件返回错误，则终止程序执行。可以通过定义?NDEBUG?来关闭 assert，但是需要在源代码的开头，include <assert.h>?之前。
#define NDEBUG // 加上这行，则 assert 不可用
#include <assert.h>
assert( p != NULL ); // assert 不可用
=========================================================================
sizeof()
-
sizeof 对数组，得到整个数组所占空间大小。 -
sizeof 对指针，得到指针本身所占空间大小。
=========================================================================
#pragma pack(n)
设定结构体、联合以及类成员变量以 n 字节方式对齐
#pragma pack(push) // 保存对齐状态
#pragma pack(4) // 设定为 4 字节对齐
struct test
{
char m1;
double m4;
int m3;
};
#pragma pack(pop) // 恢复对齐状态
? =========================================================================
位域：
Bit?mode:?2;????//?mode?占?2?位
类可以将其（非静态）数据成员定义为位域（bit-field），在一个位域中含有一定数量的二进制位。当一个程序需要向其他程序或硬件设备传递二进制数据时，通常会用到位域。
=================================================================
volatile
volatile?int?i?=?10;?
-
volatile 关键字是一种类型修饰符，用它声明的类型变量表示可以被某些编译器未知的因素（操作系统、硬件、其它线程等）更改。所以使用 volatile 告诉编译器不应对这样的对象进行优化。 -
volatile 关键字声明的变量，每次访问时都必须从内存中取出值（没有被 volatile 修饰的变量，可能由于编译器的优化，从 CPU 寄存器中取值） -
const 可以是 volatile （如只读的状态寄存器） -
指针可以是 volatile
=========================================================================
extern "C"
extern "C"?的作用是让 C++ 编译器将?extern "C"?声明的代码当作 C 语言代码处理，可以避免 C++ 因符号修饰导致代码不能和C语言库中的符号进行链接的问题。
"C" 使用
#ifdef?__cplusplus
extern?"C"?{
#endif
void?*memset(void?*,?int,?size_t);
#ifdef?__cplusplus
}
#endif
=================================================================
struct 和 typedef struct
C 中
//?c
typedef?struct?Student?{
????int?age;?
}?S;
等价于
//?c
struct?Student?{?
????int?age;?
};
typedef?struct?Student?S;
此时?S?等价于?struct Student，但两个标识符名称空间不相同。
另外还可以定义与?struct Student?不冲突的?void Student() {}。
C++ 中
由于编译器定位符号的规则（搜索规则）改变，导致不同于C语言。
一、如果在类标识符空间定义了?struct Student {...};，使用?Student me;?时，编译器将搜索全局标识符表，Student?未找到，则在类标识符内搜索。
即表现为可以使用?Student?也可以使用?struct Student，如下：
//?cpp
struct?Student?{?
????int?age;?
};
void?f(?Student?me?);???????//?正确，"struct"?关键字可省略
二、若定义了与?Student?同名函数之后，则?Student?只代表函数，不代表结构体，如下：
typedef?struct?Student?{?
????int?age;?
}?S;
void?Student()?{}???????????//?正确，定义后?"Student"?只代表此函数
//void?S()?{}???????????????//?错误，符号?"S"?已经被定义为一个?"struct?Student"?的别名
int?main()?{
????Student();?
????struct?Student?me;??????//?或者?"S?me";
????return?0;
}
C++ 中 struct 和 class
总的来说，struct 更适合看成是一个数据结构的实现体，class 更适合看成是一个对象的实现体。
区别
-
最本质的一个区别就是默认的访问控制
-
默认的继承访问权限。struct 是 public 的，class 是 private 的。? -
struct 作为数据结构的实现体，它默认的数据访问控制是 public 的，而 class 作为对象的实现体，它默认的成员变量访问控制是 private 的。
=========================================================================
union 联合
联合（union）是一种节省空间的特殊的类，一个 union 可以有多个数据成员，但是在任意时刻只有一个数据成员可以有值。当某个成员被赋值后其他成员变为未定义状态。联合有如下特点：
#include<iostream>
union?UnionTest?{
????UnionTest()?:?i(10)?{};
????int?i;
????double?d;
};
static?union?{
????int?i;
????double?d;
};
int?main()?{
????UnionTest?u;
????union?{
????????int?i;
????????double?d;
????};
????std::cout?<<?u.i?<<?std::endl;??//?输出?UnionTest?联合的?10
????::i?=?20;
????std::cout?<<?::i?<<?std::endl;??//?输出全局静态匿名联合的?20
????i?=?30;
????std::cout?<<?i?<<?std::endl;????//?输出局部匿名联合的?30
????return?0;
}
=========================================================================
C 实现 C++ 类
explicit（显式）构造函数
explicit 修饰的构造函数可用来防止隐式转换
explicit 使用
class?Test1
{
public:
????Test1(int?n)????????????//?普通构造函数
????{
????????num=n;
????}
private:
????int?num;
};
class?Test2
{
public:
????explicit?Test2(int?n)???//?explicit（显式）构造函数
????{
????????num=n;
????}
private:
????int?num;
};
int?main()
{
????Test1?t1=12;????????????//?隐式调用其构造函数，成功
????Test2?t2=12;????????????//?编译错误，不能隐式调用其构造函数
????Test2?t2(12);???????????//?显式调用成功
????return?0;
}
friend 友元类和友元函数
-
能访问私有成员 ? -
破坏封装性 -
友元关系不可传递 -
友元关系的单向性 -
友元声明的形式及数量不受限制
using
using 声明
一条?using 声明?语句一次只引入命名空间的一个成员。它使得我们可以清楚知道程序中所引用的到底是哪个名字。如：
using?namespace_name::name;
构造函数的 using 声明【C++11】
在 C++11 中，派生类能够重用其直接基类定义的构造函数。
class?Derived?:?Base?{
public:
????using?Base::Base;
????/*?...?*/
};
如上 using 声明，对于基类的每个构造函数，编译器都生成一个与之对应（形参列表完全相同）的派生类构造函数。生成如下类型构造函数：
derived(parms)?:?base(args)?{?}
using 指示
using 指示?使得某个特定命名空间中所有名字都可见，这样我们就无需再为它们添加任何前缀限定符了。如：
using?namespace_name?name;
尽量少使用 `using 指示` 污染命名空间
一般说来，使用 using 命令比使用 using 编译命令更安全，这是由于它只导入了制定的名称。如果该名称与局部名称发生冲突，编译器将发出指示。using编译命令导入所有的名称，包括可能并不需要的名称。如果与局部名称发生冲突，则局部名称将覆盖名称空间版本，而编译器并不会发出警告。另外，名称空间的开放性意味着名称空间的名称可能分散在多个地方，这使得难以准确知道添加了哪些名称。
using 使用
尽量少使用?using 指示
using?namespace?std;
应该多使用?using 声明
int?x;
std::cin?>>?x?;
std::cout?<<?x?<<?std::endl;
或者
using?std::cin;
using?std::cout;
using?std::endl;
int?x;
cin?>>?x;
cout?<<?x?<<?endl;
=========================================================================
:: 范围解析运算符
分类
-
全局作用域符（::name）：用于类型名称（类、类成员、成员函数、变量等）前，表示作用域为全局命名空间 -
类作用域符（class::name）：用于表示指定类型的作用域范围是具体某个类的 -
命名空间作用域符（namespace::name）:用于表示指定类型的作用域范围是具体某个命名空间的
:: 使用
int?count?=?0;????????//?全局（::）的?count
class?A?{
public:
????static?int?count;?//?类?A?的?count（A::count）
};
int?main()?{
????::count?=?1;??????//?设置全局的?count?的值为?1
????A::count?=?2;?????//?设置类?A?的?count?为?2
????int?count?=?0;????//?局部的?count
????count?=?3;????????//?设置局部的?count?的值为?3
????return?0;
}
=========================================================================
enum 枚举类型
限定作用域的枚举类型
enum?class?open_modes?{?input,?output,?append?};
不限定作用域的枚举类型
enum?color?{?red,?yellow,?green?};
enum?{?floatPrec?=?6,?doublePrec?=?10?};
=========================================================================
decltype
decltype 关键字用于检查实体的声明类型或表达式的类型及值分类。语法：
decltype?(?expression?)
使用
//?尾置返回允许我们在参数列表之后声明返回类型
template?<typename?It>
auto?fcn(It?beg,?It?end)?->?decltype(*beg)
{
????//?处理序列
????return?*beg;????//?返回序列中一个元素的引用
}
//?为了使用模板参数成员，必须用?typename
template?<typename?It>
auto?fcn2(It?beg,?It?end)?->?typename?remove_reference<decltype(*beg)>::type
{
????//?处理序列
????return?*beg;????//?返回序列中一个元素的拷贝
}
=========================================================================
引用：
左值引用
常规引用，一般表示对象的身份。
右值引用
右值引用就是必须绑定到右值（一个临时对象、将要销毁的对象）的引用，一般表示对象的值。
右值引用可实现转移语义（Move Sementics）和精确传递（Perfect Forwarding），它的主要目的有两个方面：
引用折叠
-
X& &、X& &&、X&& & 可折叠成 X& -
X&& && 可折叠成 X&&
宏
成员初始化列表
好处
-
更高效：少了一次调用默认构造函数的过程。 -
有些场合必须要用初始化列表：
-
常量成员，因为常量只能初始化不能赋值，所以必须放在初始化列表里面 -
引用类型，引用必须在定义的时候初始化，并且不能重新赋值，所以也要写在初始化列表里面 -
没有默认构造函数的类类型，因为使用初始化列表可以不必调用默认构造函数来初始化，而是直接调用拷贝构造函数初始化。
initializer_list 列表初始化【C++11】
用花括号初始化器列表列表初始化一个对象，其中对应构造函数接受一个?std::initializer_list?参数.
initializer_list 使用
#include?<iostream>
#include?<vector>
#include?<initializer_list>
template?<class?T>
struct?S?{
????std::vector<T>?v;
????S(std::initializer_list<T>?l)?:?v(l)?{
?????????std::cout?<<?"constructed?with?a?"?<<?l.size()?<<?"-element?list\n";
????}
????void?append(std::initializer_list<T>?l)?{
????????v.insert(v.end(),?l.begin(),?l.end());
????}
????std::pair<const?T*,?std::size_t>?c_arr()?const?{
????????return?{&v[0],?v.size()};??//?在?return?语句中复制列表初始化
???????????????????????????????????//?这不使用?std::initializer_list
????}
};
template?<typename?T>
void?templated_fn(T)?{}
int?main()
{
????S<int>?s?=?{1,?2,?3,?4,?5};?//?复制初始化
????s.append({6,?7,?8});??????//?函数调用中的列表初始化
????std::cout?<<?"The?vector?size?is?now?"?<<?s.c_arr().second?<<?"?ints:\n";
????for?(auto?n?:?s.v)
????????std::cout?<<?n?<<?'?';
????std::cout?<<?'\n';
????std::cout?<<?"Range-for?over?brace-init-list:?\n";
????for?(int?x?:?{-1,?-2,?-3})?//?auto?的规则令此带范围?for?工作
????????std::cout?<<?x?<<?'?';
????std::cout?<<?'\n';
????auto?al?=?{10,?11,?12};???//?auto?的特殊规则
????std::cout?<<?"The?list?bound?to?auto?has?size()?=?"?<<?al.size()?<<?'\n';
//??? templated_fn({1, 2, 3});?//?编译错误！“?{1, 2, 3}?”不是表达式，
?????????????????????????????//?它无类型，故?T?无法推导
????templated_fn<std::initializer_list<int>>({1,?2,?3});?//?OK
????templated_fn<std::vector<int>>({1,?2,?3});???????????//?也?OK
}
|