环境
liunx：g++编译环境
win：MinGW+vscode
数据
类型
| 类型 | 关键字 |
|---|---|
| 布尔型 | bool |
| 字符型 | char |
| 整型 | int |
| 浮点型 | float |
| 双浮点型 | double |
| 无类型 | void |
| 宽字符型 | wchar_t |
类型修饰符：
- signed
- unsigned
- short
- long
存储
- auto 自动推断类型
auto f=3.14; //double - register 存在寄存器中
register int miles; - static 内容不释放，
- extern 外部文件定义的变量或函数
extern int count; - mutable 仅适用于类的对象
- thread_local 在创建线程时创建，并在销毁线程时销毁
常量
整数
85 // 十进制
0213 // 八进制
0x4b // 十六进制
30 // 整数
30u // 无符号整数
30l // 长整数
30ul // 无符号长整数
浮点
3.14159 // 合法的
314159E-5L // 合法的
510E // 非法的：不完整的指数
210f // 非法的：没有小数或指数
.e55 // 非法的：缺少整数或分数
布尔
true 值代表真。
false 值代表假。
字符
| 转义序列 | 含义 |
|---|---|
| \ \ | 字符 |
| ’ ’ | 字符 |
| " " | 字符 |
| ? ? | 字符 |
| \a | 警报铃声 |
| \b | 退格键 |
| \f | 换页符 |
| \n | 换行符 |
| \r | 回车 |
| \t | 水平制表符 |
| \v | 垂直制表符 |
| \ooo | 一到三位的八进制数 |
| \xhh . . . | 一个或多个数字的十六进制数 |
字符串
char site[7] = {'R', 'U', 'N', 'O', 'O', 'B', '\0'};
char site[] = "RUNOOB";
| 函数 | 目的 |
|---|---|
| strcpy(s1,s2); | 复制字符串 s2 到字符串 s1。 |
| strcat(s1, s2); | 连接字符串 s2 到字符串 s1 的末尾。连接字符串也可以用 + 号，例如: string str1 = “runoob”; string str2 = “google”; string str = str1 + str2; |
| strlen(s1); | 返回字符串 s1 的长度。 |
| strcmp(s1,s2); | 如果 s1 和 s2 是相同的，则返回 0；如果 s1<s2 则返回值小于 0；如果 s1>s2 则返回值大于 0。 |
| strchr(s1,ch); | 返回一个指针，指向字符串 s1 中字符 ch 的第一次出现的位置。 |
| strstr(s1, s2); | 返回一个指针，指向字符串 s1 中字符串 s2 的第一次出现的位置。 |
string str1 = "runoob";
string str2 = "google";
string str3;
str3 = str1; // 复制 str1 到 str3
str3 = str1 + str2;// 连接 str1 和 str2
str3.size();// 连接后，str3 的总长度
定义常量
#define LENGTH 10
数组
一维
double balance[10];//声明
double balance[5] = {1000.0, 2.0, 3.4, 7.0, 50.0};//初始化个数小于5
double balance[] = {1000.0, 2.0, 3.4, 7.0, 50.0};//初始化
double salary = balance[9];//访问
二维
int a[3][4] = {
{0, 1, 2, 3} , /* 初始化索引号为 0 的行 */
{4, 5, 6, 7} , /* 初始化索引号为 1 的行 */
{8, 9, 10, 11} /* 初始化索引号为 2 的行 */
};
指向数组的指针
数组名是指向数组中第一个元素的常量指针
double *p;
double runoobAarray[10];
p = runoobAarray;
从函数返回数组
如果您想要从函数返回一个一维数组，您必须声明一个返回指针的函数，如下：
int * myFunction(){}
控制语句
| 循环类型 | 描述 |
|---|---|
| while 循环 | 当给定条件为真时，重复语句或语句组。它会在执行循环主体之前测试条件。 |
| for 循环 | 多次执行一个语句序列，简化管理循环变量的代码。 |
| do…while 循环 | 在循环主体结尾测试条件 |
| 嵌套循环 | 您可以在 while、for 或 do…while 循环内使用一个或多个循环。 |
| 控制语句 | 描述 |
|---|---|
| break 语句 | 终止 loop 或 switch 语句，程序流将继续执行紧接着 loop 或 switch 的下一条语句。 |
| continue 语句 | 引起循环跳过主体的剩余部分，立即重新开始测试条件。 |
| goto 语句 | 将控制转移到被标记的语句。但是不建议在程序中使用 goto 语句。 |
| 语句 | 描述 |
|---|---|
| if 语句 | 一个 if 语句 由一个布尔表达式后跟一个或多个语句组成。 |
| if…else 语句 | 一个 if 语句 后可跟一个可选的 else 语句，else 语句在布尔表达式为假时执行。 |
| 嵌套 if 语句 | 您可以在一个 if 或 else if 语句内使用另一个 if 或 else if 语句。 |
| switch 语句 | 一个 switch 语句允许测试一个变量等于多个值时的情况。 |
| 嵌套 switch 语句 | 您可以在一个 switch 语句内使用另一个 switch 语句。 |
? : 运算符
`Exp1 ? Exp2 : Exp3;` Exp1 为真，则计算 Exp2 的值。Exp1 为假，则计算 Exp3 的值。
函数
return_type function_name( parameter list )
{
body of the function
}
形参数
| 调用类型 | 描述 |
|---|---|
| 传值调用 | 该方法把参数的实际值赋值给函数的形式参数。在这种情况下，修改函数内的形式参数对实际参数没有影响。 |
| 指针调用 | 该方法把参数的地址赋值给形式参数。在函数内，该地址用于访问调用中要用到的实际参数。这意味着，修改形式参数会影响实际参数。 |
| 引用调用 | 该方法把参数的引用赋值给形式参数。在函数内，该引用用于访问调用中要用到的实际参数。这意味着，修改形式参数会影响实际参数。 |
Lambda 函数
[capture](parameters)->return-type{body}
auto f = [](int a) -> int { return a + 1; };
std::cout << f(1) << std::endl; // 输出: 2
模板函数
不限定类型
template <typename type> ret-type func-name(parameter list)
{
// 函数的主体
}
template <typename T> inline T const& Max (T const& a, T const& b)
//inline 内联没有函数调用的开销，效率高，适用于代码少，运行时间短的函数
//使用const为了不让修改
//T 替代了数据类型（int,double...)
{
return a < b ? b:a;
}
//调用
int i = 39;
int j = 20;
cout << "Max(i, j): " << Max(i, j) << endl;
模板类
template <class type> class class-name {
}
template <class T> class Stack {
private:
vector<T> elems; // 元素
public:
void push(T const&); // 入栈
void pop(); // 出栈
T top() const; // 返回栈顶元素
bool empty() const{ // 如果为空则返回真。
return elems.empty();
}
};
//调用
Stack<int> intStack; // int 类型的栈
intStack.push(7); // 操作 int 类型的压栈
cout << intStack.top() <<endl;
指针和引用
指针
指针是一个变量，其值为另一个变量的地址。
int *ip; /* 一个整型的指针 */
double *dp; /* 一个 double 型的指针 */
float *fp; /* 一个浮点型的指针 */
char *ch; /* 一个字符型的指针 */
int var = 20; // 实际变量的声明
int *ip; // 指针变量的声明
ip = &var; // 在指针变量中存储 var 的地址
如果没有确切的地址可以赋值，为指针变量赋一个 NULL 值.NULL 值的指针被称为空指针。
引用
引用变量是一个别名，也就是说，已存在变量数值的另一个名字。
int i = 17;
int& r = i;
& 读作引用，可以读作 "r 是一个初始化为 i 的整型引用"
// 把引用作为参数
void swap(int& x, int& y);
swap(a, b);/* 调用函数来交换值 */
//把引用作为返回值
double& setValues(int i) {
double& ref = vals[i];
return ref; // 返回第 i 个元素的引用，ref 是一个引用变量，ref 引用 vals[i]，最后再返回 shit。
}
面向对象
类&对象
类：变量与函数的混合体
对象：类的复制
class Box {
public:
double length; // 盒子的长度
double breadth; // 盒子的宽度
double height; // 盒子的高度
};
Box Box1; // 声明 Box1，类型为 Box
Box Box2; // 声明 Box2，类型为 Box
访问修饰符
class Base {
public: // 公有成员,公有成员在程序中类的外部是可访问的
protected: // 受保护成员,成员在派生类（即子类）中是可访问的。
private: // 私有成员,私有成员变量或函数在类的外部是不可访问的，甚至是不可查看的
};
构造与析构
class Line {
public:
void setLength(double len );
double getLength( void ); Line(); // 这是构造函数声明,在每次创建类的新对象时执行。
~Line(); // 这是析构函数声明,每次删除所创建的对象时执行。
private:
double length;
};
拷贝构造
class Line {
public:
int getLength( void );
Line( int len );// 简单的构造函数
Line( const Line &obj); // 拷贝构造函数
~Line(); // 析构函数
private: int *ptr;
};
类的友元函数
类的友元函数是定义在类外部，但有权访问类的所有私有（private）成员和保护（protected）成员。
class Box
{
double width;
public:
double length;
friend void printWidth( Box box );
void setWidth( double wid );
};
this
this 指针是所有成员函数的隐含参数。因此，在成员函数内部，它可以用来指向调用对象。
class Box {
public: // 构造函数定义
Box(double l=2.0, double b=2.0, double h=2.0)
{
cout <<"Constructor called." << endl;
length = l;
breadth = b;
height = h;
}
double Volume()
{
return length * breadth * height;
}
int compare(Box box) {
return this->Volume() >box.Volume();
}
};
指向类的指针
类的指针与指向结构的指针类似，访问指向类的指针的成员，需要使用成员访问运算符 ->，就像访问指向结构的指针一样。
Box Box1(3.3, 1.2, 1.5); // Declare box1
Box Box2(8.5, 6.0, 2.0); // Declare box2
Box *ptrBox; // Declare pointer to a class.
// 保存第一个对象的地址
ptrBox = &Box1;
继承
避免重复
class <派生类名>:<继承方式1><基类名1>,<继承方式2><基类名2>,…
{
<派生类类体>
};
// 基类
class Animal {
// eat() 函数
// sleep() 函数
};
//派生类
class Dog : public Animal {
// bark() 函数
};
访问
| 访问 | public | protected | private |
|---|---|---|---|
| 同一个类 | yes | yes | yes |
| 派生类 | yes | yes | no |
| 外部的类 | yes | no | no |
| 继承类型 |
- 公有继承（public）：当一个类派生自公有基类时，基类的公有成员也是派生类的公有成员，基类的保护成员也是派生类的保护成员，基类的私有成员不能直接被派生类访问，但是可以通过调用基类的公有和保护成员来访问。
- 保护继承（protected）： 当一个类派生自保护基类时，基类的公有和保护成员将成为派生类的保护成员。
- 私有继承（private）：当一个类派生自私有基类时，基类的公有和保护成员将成为派生类的私有成员。
函数重载
依据参数，区分函数
class printData
{
public:
void print(int i) {
cout << "整数为: " << i << endl;
}
void print(double f) {
cout << "浮点数为: " << f << endl;
}
void print(char c[]) {
cout << "字符串为: " << c << endl;
}
};
异常
捕捉异常
try
{
// 保护代码
}catch( ExceptionName e1 )
{
// catch 块
}catch( ExceptionName e2 )
{
// catch 块
}catch( ExceptionName eN )
{
// catch 块
}
抛出异常
double division(int a, int b)
{
if( b == 0 )
{
throw "Division by zero condition!";
}
return (a/b);
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
