备份笔记，以供参考。

优秀的教程网站：https://www.learncpp.com/
C++的参考手册：https://zh.cppreference.com/

目录不分先后

基本

int 定义变量

1
2
3
std::cout <<  //输出
<< '\n'       //换行
std::cin>> x ;//输入

函数声明

1
2
3
return-type identifier() 
{
}

调用函数时，不要忘记在函数名称后包含括号 （）

定义新函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include <iostream> 

void doPrint() 
{
    std::cout << "In doPrint()\n";       
}


int main()
{
    std::cout << "Starting main()\n";
    doPrint(); //使用新函数
    std::cout << "Ending main()\n";

    return 0;
}

返回值

用于非void 定义的函数 void不行
return 函数本身
每个int 定义的函数必须有返回值
它会导致函数立即返回到调用方。

定义#define

类似于定义

1
2
3
4
5
6
7
8
9
#include <iostream>
#define MY_NAME "Alex"

int main()
{
    std::cout << "My name is: " << MY_NAME;

    return 0;
}

头文件

方便声明导入的文件 .h

所有可以定义的变量

布尔值

bool
一般情况使用1和0作为关键字
启用

1
std::cin >> std::boolalpha;//时则使用关键字 true 和 false （都是小写）

保存字符

char //字符文字总是放在单引号之间（例如’g’，’1’，’’’）

1
2
3
4
5
char ch1{ 'a' }; // (preferred)
  std::cout << ch1; // cout prints character 'a'
  char ch{};
  std::cin >> ch; // ch = 'a', "bcd" is left queued.
  std::cout << "You entered: " << ch << '\n';

没什么用了
wchar_t
char16_t
char32_t
short
int
long
long long

浮点数对于存储非常大或非常小的数字非常有用，包括那些具有小数分量的数字。
float fValue;
double dValue;
long double ldValue;
double
long double

If判断

if (condition) true_statement;
如果 括号条件允许 则执行

1
2
3
4
if (condition)    //如果
    true_statement;
else              //否则
    false_statement;

简单符号表达if else ?:
(condition) ? expression1 : expression2;
如果条件的计算结果为 true，则执行表达式 1，否则执行表达式 2。请注意，表达式 2 不是可选的。

转义序列

换行 \n
水平拉开距离 \t
警报 \a 发出警报，例如哔哔声
退格 \b 将光标向后移动一个空格
表单馈送 \f 将光标移动到下一个逻辑页
换行符 \n 将光标移动到下一行
回车 \r 将光标移动到行首
水平选项卡 \t 打印水平选项卡
垂直选项卡 \v 打印垂直选项卡
单引号 ' 打印单个报价单
双引号 " 打印双引号
反斜杠 \ 打印反斜杠。
问号 ? 打印问号。不再相关。您可以使用未转义的问号。
八进制数 \（数字） 转换为由八进制表示的字符
十六进制数 \x（数字） 转换为由十六进制数表示的字符

const 常量

1
const double gravity; //定义一个常量 无法再次更改

启用字符串

#include <string>
启用 #include <string_view>
创建字符串 std::string X {};
别忘了加上""
要将整行输入读入字符串，最好改用该函数（高级输入） std::getline()
std::getline(std::cin >> std::ws, name);
小函数 << name.length() 或std::ssize() 计算有多少个字
std：：string_view提供对现有字符串（C 样式字符串文本、std：：字符串或 char 数组）的只读访问权限，而无需创建副本。

1
2
std::string s{ "Hello, world!" };
std::cout << s << '\n';

基本数学运算

一元加号 + +x x 的值
一元减号 - -x x 的相反数

算子 象征 形式 操作
加法 + x + y x 加 y
减法 - x - y x 减去 y
乘法 * x * y x 乘以 y
划分 / x / y x 除以 y
模量（余数） % x % y x除以y得的余数

#include<cmath>启用指数运算 使用 pow（）函数：

1
double x{ std::pow(3, 2) };
1
2
3
4
5
6
7
8
9
10
#include<stdio.h>
#include<math.h>
int main()
{
    int a,b,ret;
    scanf("%d,%d", &a, &b);
    ret = pow(a,b);    //求出a的b次方
    printf("%d", ret);
    return 0;
}

递增和递减变量

前缀增量（预增量） ++ ++x 递增 x，然后返回 x
前缀递减（预递减） –– ––x 递减 x，然后返回 x
后缀增量（后缀增量）++ x++ 复制 x，然后递增 x，然后返回副本
后缀递减（后递减） –– x–– 复制 x，然后递减 x，然后返回副本

关系运算符

大于 > x > y 如果 x 大于 y，则为真，否则为假
小于 < x < y 如果 x 小于 y，则为真，否则为假
大于或等于 >= x >= y 如果 x 大于或等于 y，则为真，否则为假
小于或等于 <= x < = y 如果 x 小于或等于 y，则为真，否则为假
平等 == x == y 如果 x 等于 y，则为真，否则为假
不等式 != x ！= y 如果 x 不等于 y，则为真，否则为假
这些运算符中的每一个的计算结果均为布尔值 true （1） 或 false （0）

逻辑

逻辑 不 ! ！x 如果 x 为假，则为真，如果 x 为真，则为假
逻辑 和 && x&&y 如果 x 和 y 都为真，则为真，否则为假
逻辑 或 || x ||y 如果 x 或 y 为真，则为真，否则为假

如果逻辑 NOT 旨在对其他运算符的结果进行操作，则其他运算符及其操作数需要括在括号中。

自定义命名空间

namespace goo
在下面写内容 ，类似于函数 可以被调用
调用 std::cout << foo::doSomething(4, 3) << '\n';
这样可以调用命名重复的函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
namespace foo
{
    int doSomething(int x, int y)
    {
        return x + y;
    }
}

namespace goo 
{
    int doSomething(int x, int y)
    {
        return x - y;
    }
}

int main()
{
    std::cout << goo::doSomething(4, 3) << '\n'; 
    return 0;
}

情况选择 switch与case

条件的计算结果必须为整数类型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
switch（X）                                                        
{
        case 1:        //x=1
            std::cout << "One";
            return;                                                                           //不加return 会导致 fallthrough（继续执行下一个case）
        case 2:                                         
        x=2            //在代码中加入[[fallthrough]]可以阻止编译器报错
            std::cout << "Two";
            return;
        case 3:                                         x=3                             
            std::cout << "Three";
            return;
        default:        //都不是
            std::cout << "Unknown";
            return;
    }

return可以换成break。这允许我们在不退出整个函数的情况下退出继续执行在这个函数中处switch其他内容

转到goto

1
2
if (x < 0.0)
       goto tryAgain;

尽量少用

循环语句 while

while (condition) 别写；了 满足条件 执行
statement;

1
2
3
4

while (true)  //无限循环
{
}

do-while
do-while 循环将检查条件。如果条件的计算结果为否 ，则执行路径将跳回到 do-while 循环的顶部并再次执行它

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

do
    {
        std::cout << "Please make a selection: \n";
        std::cout << "1) Addition\n";
        std::cout << "2) Subtraction\n";
        std::cout << "3) Multiplication\n";
        std::cout << "4) Division\n";
        std::cin >> selection;
    }
    while (selection != 1 && selection != 2 &&
        selection != 3 && selection != 4);

更加简洁的循环for

1
2
3
4
5
6

for (int count{ 1 }; count <= 10; ++count) 
//别写；了
//可以多弄几个
for (int x{ 0 }, y{ 9 }; x < 10; ++x, --y)

随机数生成（伪随机而已）

加入引用

#include <ctime>
产生一定范围随机数的通用表示公式是：

1
2
3
4
5
6
7
8
9
10
11

int main()
{
    srand((int)time(0));  // 产生随机种子  把0换成NULL也行
    for (int i = 0; i < 10; i++)
    {
        cout << rand()%100<< " ";
    }
    return 0;
}

要取得[0,n) 就是rand（）%n 表示 从0到n-1的数
要取得[a,b)的随机整数，使用(rand() % (b-a))+ a;
要取得[a,b]的随机整数，使用(rand() % (b-a+1))+ a;
要取得(a,b]的随机整数，使用(rand() % (b-a))+ a + 1;
通用公式:a + rand() % n；其中的a是起始值，n是整数的范围。
要取得a到b之间的随机整数，另一种表示：a + (int)b * rand() / (RAND_MAX + 1)。
要取得0～1之间的浮点数，可以使用rand() / double(RAND_MAX)。

函数模板

函数模板实际上不是函数 - 它们的代码不是直接编译或执行的。
相反，函数模板有一个作用：生成函数（编译和执行）
用于简化函数
//template 关键字告诉C++编译器 要开始泛型编程了
//T - 参数化数据类型
template < 类型形式参数表 ，第二个形式> （定义了一定要用，否则会报错）
类型 函数名 (形式参数表)
{
//语句序列
}
所谓函数模板，实际上是建立一个通用函数，其函数类型和形参类型不具体指定，
用一个虚拟的类型来代表。这个通用函数就称为函数模板。

例：

1
2
3
4
5
template <typename X>
X max(X x, X y)
{
    return (x > y) ? x : y;
}
1
2
3
4
5
6
int main()
{
    std::cout << max<int>(1, 2) << '\n'; // instantiates and calls function max<int>(int, int)

    return 0;
}

左值引用，快速赋值

int& y或者const int& y可以绑定任何类型的参数 只是传递值就用int&

对于复制成本低廉的对象，复制的成本类似于绑定的成本，因此我们倾向于按值传递，因此生成的代码会更快。
对于复制成本高昂的对象，复制的成本占主导地位，因此我们倾向于传递（const）引用以避免复制。

1
2
3
4
5
6
7
8
9
10
11
12
void addOne(int& y) 
{
    ++y; 
}

int main()
{
 addOne(x);

    std::cout << "value = " << x << '\n';
}
//快速将x赋值为y

指针

指针是一个变量
地址的运算符 （&）std::cout << &x ； 将显示x的存储位置（16位）

&符号容易引起混淆，因为它具有不同的含义，具体取决于上下文：

当跟随类型名称时，& 表示左值引用：。int& ref
在表达式的一元上下文中使用时，& 是地址运算符：。std::cout << &x
在表达式的二进制上下文中使用时，& 是按位 AND 运算符：。std::cout << x & y

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <stdio.h>

int main ()
{
   int  var = 20;    /* 实际变量的声明 */
   int  *ip;         /* 指针变量的声明 */
 
   ip = &var;  /* 在指针变量中存储 var 的地址 */
 
   printf("var 变量的地址: %p\n", &var  );
 
   /* 在指针变量中存储的地址 */
   printf("ip 变量存储的地址: %p\n", ip );
 
   /* 使用指针访问值 */
   printf("*ip 变量的值: %d\n", *ip );
 
   return 0;
}

定义野生指针 int* ptr;
最好定义空指针 int* ptr{}；

定义指定指针 指定为（左值引用x）int* ptr3{ &x }
取消引用 std::cout << *ptr << '\n';

1
2
3
4
5
6
7
8
9
10
11
12
int main()
{
    int x = 1;
    int* ip;
    ip = &x;
    std::cout << ip <<"\n" ;
    std::cout << x <<"\n";
    std::cout << &x <<"\n";


    return 0;
}

输出为ip=&x

用户定义类型

定义 语句在头文件中定义程序定义的类型

1
2
3
4
5
struct Fraction
{
	int x {};
	int y{};
};

函数体外只能进行如变量或函数定义声明等，不能执行语句或调用函数

1
2
//自定义函数名称     
using Color = int;

定义结构 使代码更加可视化。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
struct enployee
{
    std::string id{};
    int time{};
    int age{};
    int number{};

};
int main()
{
    enployee Thefirst;
        Thefirst.age = 18;
        Thefirst.id ="YourID";
}

枚举

其中每个可能的值都定义为符号常量

1
2
3
4
5
6
enum Color
{
    red,    //命令red=0
    green,  //命令green     =1
     blue,  //命令blue      =2
} ; 
1
2
3
4
5
6
7
8
9
10
int main()
{
    Color apple { red };         //枚举命令Color 自由命名局部变量apple  且apple=0
    Color shirt { green };
    Color cup { blue };    

    Color socks { white };           //错误
    Color hat { 2 };                 //错误
    return 0;
}

由于枚举器是描述性的，因此它们对于增强代码文档和可读性非常有用。
枚举类型最适合在具有少量相关常量且对象一次只需要保存其中一个值时使用。

继承

继承是一个优化代码的语句，可以减少不必要的定义。
A类继承了B类的属性和方法。
继承的最大优势是，基类中已经存在的代码不需要在子类中重写。

1
2
3
class A:public B{}；
//A是新类的名字，public是继承方式，B是要继承的类
//意思就是说我定义了一个名叫 A的类 以public的方式 来继承你B

继承主要方式有三种：public，protectd，private。不过最常用的是public。