- asm
用于在C++源码中内嵌汇编语言。
__asm mov al, 2
__asm mov dx, 0xD007
__asm out al, dx
- do
配合while使用
do
{
...
}while(1)
- if
判断
if(){
...
}else{
...
}
- return
返回
return 1;
- try
异常处理,激活异常
try
{
...
}catch(异常){
...
}
- auto
存储类型标识符
int a = 10;
auto b = a;
- double
双精度类型，一般占8个字节。
double a;
- inline
内联函数的定义将在编译时在调用处展开。inline 函数一 般由短小的语句组成，可以提高程序效率。 不管大小程序加上就好了，别的交给编译器。
inline int fuc(){
return 1;
}
- short
短整型。一般占2个字节。
short a;
- typedef
类型定义
typedef 类型 定义名；
- bool
布尔类型，可选true,false,在c++里可与Int混用。一般占1个字节。
bool a = true;
- dynamic_cast
动态转换，dynamic_cast是四个强制类型转换操作符中最特殊的一个(static_cast、dynamic_cast、const_cast、reinterpret_cast)，它支持运行时识别指针或引用。允许在运行时刻进行类型转换，从而使程序能够在一个类层次结构安全地转换类型。dynamic_cast 提供了两种转换方式，把基类指针转换成派生类指针，或者把指向基类的左值转换成派生类的引用。
//这是第一种情况
Base* base = new Derived;
if(Derived *der= dynamic_cast<Derived*>(base))
{
cout<<"第一种情况转换成功"<<endl;
}
//这是第二种情况
Base * base1 = new Base;
if(Derived *der1 = dynamic_cast<Derived*>(base1))
{
cout<<"第二种情况转换成功"<<endl;
}
else
{
cout<<"第二种情况转换失败"<<endl;
}
- int
整型。一般占4个字节。
int a;
- signed
有符号，表明该类型是有符号数，和 unsigned 相反。也就是第一个位代表正负，剩余的代表大小。数字类型（整型和浮点型）都可以用 signed 修饰。但默认就是 signed，所以一般不会显式使用。 例如：signed int 大小区间为-128-127，int a = 1，其二进制就是0000000000000001。
signed int a;
- typeid
指出指针或引用指向的对象的实际派生类型
short a;
cout<<typeid(a).name()<<endl;
输出：
short
- break
中断、跳出。用在switch语句或者循环语句中。程序遇到 break 后，即跳过该程序段，继续后面的语句执行。
while(1){
if(1 == a)
break;
}
- else
else 紧跟在 if 后面，用于对 if 不成立的情况的选择。
if(1 == a)
{
...
}else{
...
}
- long
长整型。一般占4个字节。 - long long
长长整型。一般占8个字节。 - static
静态的。静态变量作用范围在一个文件内，程序开始时分配空间，结束时释放空间，默认初始化为 0，使用时可改变其值。静态变量或静态函数，只有本文件内的代码才可访问它，它的名字（变量名或函数名）在其它文件中不可见。因此也称为"文件作用域"。在 C++ 类的成员变量被声明为 static（称为静态成员变量），意味着它被该类的所有实例所共享，也就是说当某个类的实例修改了该静态成员变量，其修改值为该类的其它所有实例所见；而类的静态成员函数也只能访问静态成员（变量或函数）。类的静态成员变量必须在声明它的文件范围内进行初始化才能使用，private 类型的也不例外。 static的值必须定义。
static int i = 1;
- union
联合，类似于 enum。不同的是 enum 实质上是 int 类型的，而 union 可以用于所有类型，并且其占用空间是随着实际类型大小变化的。
union test
{
char mark;
long num;
float score;
};
- case
用于 switch 语句中，用于不同的条件类型判断。
switch(a){
case 1:
...
break;
}
- enum
枚举类型，给出一系列固定的值。序号从0开始。
enum <类型名> {<枚举常量表>};
enum color_set1 {RED, BLUE, WHITE, BLACK};
//apple=0,orange=1,banana=1,peach=2,grape=3
enum fruit_set {apple, orange, banana=1, peach, grape}
//Sun,Mon,Tue,Wed,Thu,Fri,Sat的值分别为7、1、2、3、4、5、6
enum week {Sun=7, Mon=1, Tue, Wed, Thu, Fri, Sat};
- mutable(不常用)
易变的。只能用于类的非静态和非常量数据成员，跟constant（既C++中的const）是反义词。在C++中，mutable也是为了突破const的限制而设置的。被mutable修饰的变量，将永远处于可变的状态，即使在一个const函数中。
class CTest{
public:
int getNum() const;
private:
mutable int m_nums;
};
int CTest:getNum() const
{
m_nums++;
return 0;
}
- static_cast
强制转换之一。该运算符把 expression 转换为 type-id 类型，但没有运行时类型检查来保证转换的安全性。它主要有如下几种用法：
① 用于类层次结构中基类和子类之间指针或引用的转换。进行上行转换（把子类的指针或引用转换成基类表示）是安全的；进行下行转换（把基类指针或引用转换成子类表示）时，由于没有动态类型检查，所以是不安全的。
② 用于基本数据类型之间的转换，如把 int 转换成 char，把 int 转换成 enum。这种转换的安全性也要开发人员来保证。
③ 把空指针转换成目标类型的空指针。
④ 把任何类型的表达式转换成void类?
注意 static_cast 不能转换掉 expression 的 const、volitale、或者 __unaligned 属性。
用法：
static_cast < type-id > ( expression )
- unsigned
无符号。与signed相反。
unsigned int a;
- catch
捕捉异常。
try{
...
}catch{
...
}
- explicit
显式的.其作用是"禁止单参数构造函数"被用于自动型别转换，其中比较典型的例子就是容器类型。在这种类型的构造函数中你可以将初始长度作为参数传递给构造函数。
class CxString // 没有使用explicit关键字的类声明, 即默认为隐式声明
{
public:
CxString(int size)
{
...
}
};
CxString string2 = 10; // 这样是OK的, 为CxString预分配10字节的大小的内存
//--------------------------------------------------------
class CxString // 使用关键字explicit的类声明, 显示转换
{
public:
explicit CxString(int size)
{
...
}
};
CxString string2 = 10; // 这样是不行的, 因为explicit关键字取消了隐式转换
- namespace
命名空间。用于在逻辑上组织类，是一种比类大的结构。适合多人协同开发，避免命名冲突。
namespace sella {
namespace variant {
class String;
}
}
- struct
结构体类型，类似于 class 关键字，与 C 语言兼容（class 关键字是不与 C 语言兼容的），可以实现面向对象程序设计。 莫太纠结与class的区别，别人创建c++的时候是为了兼容C语言，兼容struct!!!
struct xx{
...
}xxx;
- using
使用空间。
using namespace std;
- char
字符类型。占1个字节。
char a = 'a';
- export
为了访问其他编译单元（如另一代码文件）中的变量或对象，对普通类型（包括基本数据类、结构和类），可以利用关键字extern，来使用这些变量或对象时；但是对模板类型，则必须在定义这些模板类对象和模板函数时，使用标准C++新增加的关键字export（导出/出口/输出）。
extern int n;
extern struct Point p;
extern class A a;
export template<class T> class Stack<int> s;
export template<class T> void f (T& t) {……}
// out.h:（声明头文件——只包含out函数的声明信息）
template<class T> void out (const T& t);
// out.cpp:（定义代码文件——包含out函数的声明[通过include]和定义等全部信息）
#include <iostream>
#include “out.h”
export template<class T> void out (const T& t) {std::cerr << t;}
- new
创建一个对象。new 运算符总是返回一个指针。与delete对应。
int* pTest = new int();
- switch
switch（转换）类似于 if-else-if 语句，是一种多分枝语句。它提供了一种简洁的书写，并且能够生成效率更好的代码。但是，switch 后面的判断只能是int（char也可以，但char本质上也是一种int类型）。switch 语句最后的 default 分支是可选的。
switch(a){
case 1:
....
break;
default:
....
break;
}
- virtual
虚的，用来实现多态之一（虚函数和引用）。
class CTest{
public:
CTest();
virtual ~CTest();
public:
virtual void getTest();
};
- class
类。使用 class 关键字声明一个类。 如果不带public等默认private
class XXX{
…
}; - extern
外部的。声明变量或函数为外部链接，即该变量或函数名在其它文件中可见。被其修饰的变量（外部变量）是静态分配空间的，即程序开始时分配，结束时释放。用其声明的变量或函数应该在别的文件或同一文件的其它地方定义（实现）。在文件内声明一个变量或函数默认为可被外部使用。在 C++ 中，还可用来指定使用另一语言进行链接，这时需要与特定的转换符一起使用。目前仅支持 C 转换标记，来支持 C 编译器链接。使用这种情况有两种形式：
extern int n;
extern "C" 声明语句
extern "C" { 声明语句块 }
- register
寄存器。声明的变量称着寄存器变量，在可能的情况下会直接存放在机器的寄存器中；但对 32 位编译器不起作用，当 global optimizations（全局优化）开的时候，它会做出选择是否放在自己的寄存器中；不过其它与 register 关键字有关的其它符号都对32位编译器有效。
在早期c语言编译器不会对代码进行优化，因此使用register关键字修饰变量是很好的补充，大大提高的速度。
register关键字请求让编译器将变量a直接放入寄存器里面，以提高读取速度，在C语言中register关键字修饰的变量不可以被取地址，但是c++中进行了优化。
c++中依然支持register关键字，但是c++编译器也有自己的优化方式，即某些变量不用register关键字进行修饰，编译器也会将多次连续使用的变量优化放入寄存器中，例如入for循环的循环变量i。
c++中也可以对register修饰的变量取地址，不过c++编译器发现程序中需要取register关键字修饰的变量的地址时，register关键字的声明将变得无效。
1.被register修饰的变量必须是CPU能够接受的类型，因为有的机器识别不了浮点型，所以register变量的长度应该小于等于整形，但现在有的机器是可以使用浮点型的register变量的。
2.在C语言中，一旦声明为寄存器变量，由于可能会保存到寄存器中，编译器是不允许对其取地址（&）的。
3.只有局部自动变量和形参可以是寄存器变量，比如在C语言中，全局变量是不能用register修饰的，并且局部静态变量也不能用register修饰。
4.register变量的个数是有限的，因为一个CPU只有那么多个寄存器，并且类型也会受到CPU的限制，并且某些寄存器只能接受特定的类型，如指针类型。
而在C++中，该关键字又有几点不同：
1.register 关键字无法在全局中定义变量，否则会被提示为寄存器无效。其实这一点在新的gcc编译器下C语言也不允许定义全局的register变量，因为生命周期直到程序结束，期间都作为寄存器变量的话明显不妥。
2.register 关键字在局部作用域中声明时，可以用 & 操作符取地址，一旦使用了取地址操作符，被定义的变量会强制存放在内存中。
1未使用寄存器组
for(int i=0;i<100000;i++){
for(int j=0;j<i;j++){
a+=i;
a-=i;
}
a+=i;
} //用时14.64秒
2使用寄存器组
for(register int i=0;i<100000;i++){
for(register int j=0;j<i;j++){
a+=i;
a-=i;
}
a+=i;
} //用时2.954秒
- sizeof
获取字节数。由于 C++ 每种类型的大小都是由编译器自行决定的，为了增加可移植性，可以用 sizeof 运算符获得该数据类型占用的字节数。
int a = 1;
cout<<sizeof(a)<<endl;
- typename
typename（类型名字）关键字告诉编译器把一个特殊的名字解释成一个类型。在下列情况下必须对一个 name 使用 typename 关键字：
1． 一个唯一的name（可以作为类型理解），它嵌套在另一个类型中的。
2． 依赖于一个模板参数，就是说：模板参数在某种程度上包含这个name。当模板参数使编译器在指认一个类型时产生了误解。
typename在下面情况下禁止使用：
1.模板定义之外，即typename只能用于模板的定义中
2.非限定类型，比如int，vector之类
3.基类列表中，比如template class C1 : T::InnerType不能在T::InnerType前面加typename
4.构造函数的初始化列表中
template <typename T>
int compare(const T &v1, const T &v2)
{
.....
return 0;
}
//------------------------------------
template <class T>
void foo() {
typename T::iterator * iter;
// ...
}
- const
常量的。所修饰的对象或变量不能被改变，修饰函数时，该函数不能改变在该函数外面声明的变量也不能调用任何非const函数。在函数的声明与定义时都要加上const，放在函数参数列表的最后一个括号后。
在 C++ 中，用 const 声明一个变量，意味着该变量就是一个带类型的常量，可以代替 #define，且比 #define 多一个类型信息，且它执行内链接，可放在头文件中声明；但在 C 中，其声明则必须放在源文件（即 .C 文件）中，在 C 中 const 声明一个变量，除了不能改变其值外，它仍是一具变量。
const double pi(3.14159);
或
const double pi = 3.14159;
- false
假的。boot类型值之一，与int的0值等同。
bool tmp = false;
- operator
操作符重载。
bool operator==(const String &other) const throw ();
bool operator!=(const String &other) const throw ();
bool operator>(const String &other) const throw ();
bool operator<(const String &other) const throw ();
String& operator=(const String &other) throw ();
String& operator=(String &&other) throw ();
String& operator=(const std::string &other) throw ();
String& operator=(const char *other) throw ();
String& operator+=(const std::string &value) throw ();
- template
模板。泛型编程。
template <typename T>
struct check
{
static_assert(sizeof(int) <= sizeof(T), "not big enough");
};
- void
空，可以作为函数返回值，表明不返回任何数据；可以作为参数，表明没有参数传入（C++中不是必须的）；可以作为指针使用。
void fuc(){
.....
}
- const_cast
该运算符用来修改类型的 const 或 volatile 属性。除了 const 或 volatile 修饰之外， type_id 和 expression 的类型是一样的。常量指针被转化成非常量指针，并且仍然指向原来的对象；常量引用被转换成非常量引用，并且仍然指向原来的对象；常量对象被转换成非常量对象。
const_cast<type_id> (expression)
- float
浮点型。占4个字节。
float a = 1.12;
- private
私有。访问控制符。被标明为 private 的字段只能在本类以及友元中访问。
class CTest{
private:
int m_a;
};
- this
自身的指针。编译器在程序背后做的事，会在函数第一个参数的位置会插入。
void setNum(int num){
m_Num = num ;
}
- volatile
volatile提醒编译器它后面所定义的变量随时都有可能改变，因此编译后的程序每次需要存储或读取这个变量的时候，都会直接从变量地址中读取数据。如果没有volatile关键字，则编译器可能优化读取和存储，可能暂时使用寄存器中的值，如果这个变量由别的程序更新了的话，将出现不一致的现象。
int flag;
void main()
{
test1();
while(0 == flag){
...
}
test2();
}
这段程序等待内存变量flag的值变为1(怀疑此处是0,有点疑问,)之后才运行test2()。变量flag的值由别的程序更改，这个程序可能是某个硬件中断服务程序。例如：如果某个按钮按下的话，就会对DSP产生中断，在按键中断程序中修改flag为1，这样上面的程序就能够得以继续运行。但是，编译器并不知道flag的值会被别的程序修改，因此在它进行优化的时候，可能会把flag的值先读入某个寄存器，然后等待那个寄存器变为1。如果不幸进行了这样的优化，那么while循环就变成了死循环，因为寄存器的内容不可能被中断服务程序修改。为了让程序每次都读取真正flag变量的值,定义如下：
volatile int flag;
- continue
- for
- protected
- throw
抛出异常
if( b == 0 )
{
throw "Division by zero condition!";
}
- wchar_t
wchar_t占两个字节 - default
明确默认的函数声明式一种新的函数声明方式，在C++11发布时做出了更新。C++11允许添加“=default”说明符到函数声明的末尾，以将该函数声明为显示默认构造函数。这就使得编译器为显示默认函数生成了默认实现，它比手动编程函数更加有效。
每当我们声明一个有参构造函数时，编译器就不会创建默认构造函数。在这种情况下，我们可以使用default说明符来创建默认说明符:
// use of defaulted functions
#include
using namespace std;
class A {
public:
A(int x){
cout << "This is a parameterized constructor";
}
A() = default;
};
int main(){
A a; //call A()
A x(1); //call A(int x)
cout<<endl;
return 0;
}
默认函数需要用于特殊的成员函数（默认构造函数，复制构造函数，析构函数等）
有兴趣的可以参照下=delete
62. friend
友元。友元可以访问与其有 friend 关系的类中的 private/protected 成员，通过友元直接访问类中的 private/protected 成员的主要目的是提高效率。友元包括友元函数和友元类。
63. public
64. true
65. while
66. delete
67. goto
68. reinterpret_cast
370
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
