关键

• 🔵未了解

• 🔴了解

• 数据类型	控制	存储	类	转换	异常
  int 整型🔴	if 如果🔴	auto 字典推导🔴	class类🔴	const_cas类型转换🔵	catch异常处理🔵
  long 长整型🔴	else 否则🔴	static 静态🔴	template模🔴板	dynamic_cast 类型转换操作符🔵	throw抛出异常🔵
  float 浮点🔴	switch判断🔴	extern其他文件定义🔵	friend友元🔴	reinterpret_cast类型转换🔵	try异常
  double 双精度🔴	case 或者🔴	mutable在常量函数修改属性🔴	union 联合体🔴	static_cast型转换操作符之🔵
  char 字符🔴	default switch的否则🔴	sizeof 长度🔴	**struct **结构体🔴
  wchar_t宽字符类型	for 循坏🔴	this 特殊指针🔴	new指向🔴
  public公开🔴	break 跳过🔴		delete释放🔴
  protected保护🔴	continue跳过循坏		operator重载操作符🔵
  private私有🔴	goto跳转🔵		virtual重写🔴override
  void函数🔴	return 返回🔴		typeid确定类型🔵
  const常量🔴	do至少会执行一次循环	register 存储类说明符(弃用)🔵	typename模板🔴
  enum 枚举🔴		export指定模板实例化(弃用)🔵
  true 真🔴	namespace 命名空间🔴	inline 内联函数
  false假的🔴	using 命名🔴	volatile未知🔵
  bool 布尔🔴	typedef新名字🔴	explicit 当构造函数被声明为explicit时，它不能用于隐式类型转换🔵
  unsigned用于声明无符号整数类型🔴
  signed符号类型🔴
  short短整型变量🔴
  asm嵌入汇编语言代码到C++🔴

关键字

例子

数据类型

int 整型

• 整型的数据类型

1

int 数据=10;

long 长整型

• 长整型

1

long 数据=100000;

short 短整型

• 短整型

1

short 数据=1;

floa 字符串

• 字符串

1

float 数据=3.1415726

double 双精度浮点型

• 浮点型

1

double 数据=3.1415926

char 字符型

1

char 字符='a'

wchar_t 宽字符类型

• wchar_t是一种宽字符类型，用于表示宽字符数据。它的大小通常是2或4个字节，可以存储更广泛的字符集，包括Unicode字符

1
2

wchar_t ch = L'A';
wchar_t str[] = L"Hello";

bool 布尔

1

bool 开关=true;

true 整的

1

bool 开关=true

fales 假的

1

bool 开关=false;

enum 枚举

1

enum 选择{A,B,C,D};

unsgned 无符号

1

unsgned 数据=1;

signed 有符号

1

signed 数据=-1;

asm 嵌入汇编

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

asm ("Assembler");//Assenmbler指汇编指令
/*
 *你会看到“asm”变成了关键字样式的字体
 *汇编指令由字符串方式填在括号里
 *有的编译器会把嵌入的汇编指令单独放在一个文件里编译
 */
//另外插入多条汇编语句：
asm(
"mov eax,1\n"
"leave\n"
"ret\n"
);
//Intel和AT&T转换。
asm(".intel_syntax\n")//Intel
asm(".att_syntax\n");//AT&T

访问修饰符

const 常量

• const修饰的属性无法被修改

1
2

const int 数据=10;  //声明一个常量数据
数据=20;   //此处会报错

volatile 随意改变

mutable 在常量中修改属性

• 用于修饰变量,此变量可以在函数常量中修改修饰过的属性

1
2
3
4

mutable int x;
void func(int key) const {
    x=key;
}

static 静态

• 未知

1

inline 内联函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14

#include <stdio.h>

inline const char *num_check(int v)
{
    return (v % 2 > 0) ? "奇" : "偶";
}

int main(void)
{
    int i;
    for (i = 0; i < 100; i++)
        printf("%02d   %s\n", i, num_check(i));
    return 0;
}

sizeof 获取大小

• 获取数据的长度

this 特殊指针

• 特殊指针

auto 推导

• 类似var 在声明变量时自动转换类型

1
2

auto x=60;     //x为int类型
auto y="哈哈"   //y为字符数组

public 公开的

• public修饰的属性和方法可在任何地方访问

1
2
3
4
5
6

class 类
{
    public:     //公开的
        int x;   //可以在其他类访问
}
cout<<x<<endl;  //在类外访问

private 私有的

• private修饰的属性和方法只可以在类内访问

1
2
3
4
5
6
7

class 类
{
    private:     //私有的
        int x;   //不可以在其他类外或者函数访问
}

cout<<x<<endl;  //会报错

protected 受保护的

• protected修饰的属性可以在子类访问

1
2
3
4
5
6
7
8
9
10
11
12
13

class 类
{
    protected:
        int x;
}
class 子类:类
{
    public:
        void 方法()
        {
            cout<<x<<endl;
        }
}

extern 其它文件定义

• 在其他文件等于在另一个文件实现

控制

if 如果

• 判断括号内容,如果为真则执行大括号的内容

1
2
3
4
5
6
7
8
9

int x=50;
if(x==50)
{
    //此处代码可执行
}
if(x==30)
{
    //此处代码不会执行
}

else 否则

• 多个判断,如果成立就执行

1
2
3
4
5
6
7
8

int x=50;
if(x==30){
    //不成立不执行
}
else
{
    //执行此处代码
}

switch 选择判断

• 判断选择执行

1
2
3
4
5
6
7
8
9

int op;
cin>>op;
switch(op)
{
    case 1:
        //执行
    case 2:
        //执行
}

case 选择

default 否则

break 打断

continue 跳过

• 跳过成立的条件 ,执行下一个循坏
• 问题:给老婆做饭,星期3没空打印出忙了没做

1
2
3
4
5
6
7
8
9
10

for (int i = 0; i < 7; i++)
{
    if (i == 3)
    {
        cout << "忙了没做" << endl;
        continue;
    }
    cout << "给老婆做饭的第"<<i<<"天"<< endl;

}

do 至少循坏1次

• 无条件提前执行

1
2
3
4
5
6
7

    int i = 10;
do  //程序开始执行一次
{
    cout << i << endl;
    i++;

}while(i <= 20);  //如果i小于等于20就退出

goto 跳转

• 跳转到标记出

1
2
3
4
5
6
7
8
9
10
11
12

op:do
{
    if (i == 15)
    {
        i = i + 1;
        goto op;
    }

    cout << i << endl;
    i++;

}while(i < 20);

return 返回

• return数据或者跳出

1
2
3
4
5
6
7
8
9

int func(int key)
{
    if(key==null) 
    {
        return 0;  //如果key等于空则跳出函数不再执行往下的代码并返回一个值;
    }
    return key;      //在此处跳出函数并返回一个值;

}

类

class 类

templata 模板

typename 模板

friend 友元

• 可以在其他类访问指定私有函数

union 联合体

• 共用内存

virtual 重写

• 重写 override

operator 重载

• 重载

typeid 确定类型

• 确定类型

new 返回指针

• 返回堆指针

delete 释放

• 释放数据

struct 结构体

• 声明结构体,与类类似

转换

const_cas

dynamic_cast

reinterpret_cast

static_cast

异常

catch 异常处理

throw 抛出异常

try 异常