c++入门（爆肝7000字！！！）

Visual studio编程与开发-社区版下载
Microsoft Visual Studio（简称VS）是开发工具包系列产品。VS是一个基本完整的开发工具集，它包括了整个软件生命周期中所需要的大部分工具，如UML工具、代码管控工具、集成开发环境(IDE)等等。所写的目标代码适用于微软支持的所有平台。

链接：https://softs.yuzhewangluo.cn/visual/index.html?source=360a&unitid=3388001709&unit=vs&e_creative=12021253408

上册
1.顺序结构
面向对象程序设计（OOP）

基本框架
#include<iostream>//头文件
using namespace std;//命名空间
int main() {//主函数
    //CODE……
    return 0;//结束
}
1
2
3
4
5
6
解释
头文件是c++程序对其他程序的引用。include是预处理命令，它并不是c++中的语句，所以没有语句分隔符：‘;’,使用时用#开头，iostream是输入输出的标准头文件（是i o stream三个词组成）

using namespace std是指明采用的命名空间的指令（C 语言省略 C语言省略C语言省略），表示使用命名空间std（标准）中的内容。命名空间是为了解决多人同时编写大型程序时名字产生冲突的问题。

int main()是主函数的起始说明，所有c++程序必须有而且只有一个main()函数，运行时，第一条运行的语句是main()函数。

int是一种数据类型——整型（后面会讲，这里只是提一下），在标准c++中规定main()函数必须声明为int(C可声明为void)

return为返回语句，一般是函数最后一条可执行语句，main()函数使用return时，数据0表示程序顺利结束。

c++中，语句和语句之间用;隔开，称为分隔符，但预处理命令、函数、{}后面不加分隔符，结构体除外。

注释符
//是单行注释符，从所在行的末尾内容都是注释内容。注释内容不会被程序执行。
例：

//我要三连！！！
1
/* */是多行注释符。
例：

/*我要三连！！！
你给了吗?
*/
1
2
3
后缀
用高级语言编写的程序称为源程序，c++源程序以.cpp为后缀。

关键字

cout语句
在c++中，输入（cin）输出(cout)是用"流"的方式实现的。在定义流对象时，系统会在内存中开辟一段缓冲区，用来暂存输入输出的数据。

cout语句一般格式为：

cout<<项目1<<项目2<<……<<项目n;
1
cout语句的作用是将流插入运算符"<<"右侧项目的内容插入输出流中，c++系统再将输出流的内容输出到显示器上。

样例：

#include<iostream>
using namespace std;
int main() {
    cout<<"点个赞吧!";
    return 0;
}
1
2
3
4
5
6
输出：
点个赞吧!

换行endl
有的人会问：那要怎么换行呢？
我们需要用到endl。
endl：end line的缩写，换行并清空缓冲区
样例：

#include<iostream>
using namespace std;
int main() {
    cout<<"点个赞吧!"<<endl<<"求求了。";
    return 0;
}
1
2
3
4
5
6
输出：
点个赞吧!
求求了。

变量
定义变量必须先定义后使用。定义变量时，给变量开辟对应大小的存储单元来存放数据。
定义变量格式：

数据类型 变量1,变量2,……变量n;
1
变量名只能由字母，数字，下划线组成，而且不能用关键字做变量名。
例如：a_max是合法的，5x是非法的，cout也是非法的。

数据类型
数据类型    意思
int    整型
long    长整型
long long    超长整型
char    字符型
string（需要头文件：string）    字符串
bool    布尔型
void    无类型
short    短型
fioat    单精度浮点数
double    双精度浮点数
赋值
int a,b,c;
1
就定义了3个整型变量，可以把0、1、2、3这样的整数赋值给a、b、c，但是吧1145.14、22.33、88.48这样的浮点数赋值给它们那就会自动取整。截取小数部分。

例如：

#include<iostream>
using namespace std;
int main() {
    int a,b,c;
    a=999;//把999赋值给a
    b=100;//把100赋值给b
    c=a*b;//把a*b赋值给c
    cout<<a<<endl<<b<<endl<<c;
    return 0;
}
1
2
3
4
5
6
7
8
9
10
运行结果：
990
100
99000

运算符号
数学符号    c++运算符号
+    +
－    -
×    *
÷    /
自增
i=i+1;
1
该语句的含义是先把i的值加1，再赋值给i。还可以写成i++，++叫自加运算符或自增运算符。

变量+1有4种方法：
1：变量名=变量名+1
2：变量名+=1
3：变量名++
4：++变量名

单独使用自增时n++和++n一样
但在赋值语句中，结果就不同了。
例如：

#include<iostream>
using namespace std;
int main() {
    int a=100,b=100;
    int x=a++;
    int y=++b;
    cout<<x<<" "<<y;
    return 0;
}
1
2
3
4
5
6
7
8
9
运行结果：
100 101
过程图：

a    b    x    y
100    100        
101    101    100    101
解释：
语句x=a++表示将a的值赋值给x后，a再加1
语句y=++b表示将b加1，再把b的值赋值给y
因为自增运算符的结合方向为自左向右。

复合运算符
n*=2;//相当于n=n*2
1
在赋值符‘=’之前加上‘*’运算符，构成复合运算符

n+=i 相当于 n=n+i
n-=i 相当于 n=n-i
n/=i 相当于 n=n/i（i≠0）
n%=i 相当于 n=n%i（i≠0）
……

交换的三种方法（第三个变量，不用第三个变量）
swap()交换函数暂不讲

第三个变量
#include<iostream>
using namespace std;
int main() {
    int a,b,t;
    a=10;
    b=20;
    cout<<"交换前"<<endl<<"a="<<a<<" "<<"b="<<b<<endl;
    t=a;
    a=b;
    b=t;
    cout<<"交换后"<<endl<<"a="<<a<<" "<<"b="<<b;
    return 0
}
1
2
3
4
5
6
7
8
9
10
11
12
13
运行结果：
交换前
a=10 b=20
交换后
a=20 b=10

不用第三个变量
加减法
a=b-a;
b-=a;
a+=b;
1
2
3
乘除法
a=a*b;
b/=a;
a/=b;
1
2
3
cin语言
引入例题：
输入两个正整数a,b（在int范围内）输出他们的和。
输入：
12 3
输出：
15
输入由cin来实现，如cin>>a就是输入一个数并赋值 给a;
cin语句的格式一般为：

cin>>变量1>>变量2>>……>>变量n;
1
那么此题的代码为：

#include<iostream>
using namespace std;
int main() {
    int a,b;
    cin>>a>>b;
    cout<<a+b;
    return 0;
}
1
2
3
4
5
6
7
8
其中：

cin>>a>>b;
1
相当于：

cin>>a;
cin>>b;
1
2
浮点数float和double
在前面我讲过fioat和double都是数据类型，都能存放小数。(引用部分转载https://www.runoob.com/w3cnote/float-and-double-different.html?）

float和double的区别：
float 单精度浮点数在机内占 4 个字节，用 32 位二进制描述。
double 双精度浮点数在机内占 8 个字节，用 64 位二进制描述。
浮点数在机内用指数型式表示，分解为：数符，尾数，指数符，指数四部分。
数符占 1 位二进制，表示数的正负。
指数符占 1 位二进制，表示指数的正负。
尾数表示浮点数有效数字，0.xxxxxxx, 但不存开头的 0 和点。
指数存指数的有效数字。
指数占多少位，尾数占多少位，由计算机系统决定。
可能是数符加尾数占 24 位，指数符加指数占 8 位 – float。
数符加尾数占 48 位，指数符加指数占 16 位 – double。
知道了这四部分的占位，按二进制估计大小范围，再换算为十进制，就是你想知道的数值范围。
对编程人员来说，double 和 float 的区别是 double 精度高，有效数字 16 位，float 精度 7 位。但 double 消耗内存是 float 的两倍，double 的运算速度比 float 慢得多，C 语言中数学函数名称 double 和 float 不同，不要写错，能用单精度时不要用双精度（以省内存，加快运算速度）。
类型 比特数 有效数字 数值范围
float 32 6-7 -3.410(-38)～3.410(38)
double 64 15-16 -1.710(-308)～1.710(308)
long double 128 18-19 -1.210(-4932)～1.210(4932)
简单来说，Float 为单精度，内存中占 4 个字节，有效数位是 7 位（因为有正负，所以不是8位），在我的电脑且 VC++6.0 平台中默认显示是6位有效数字；double为 双精度，占 8 个字节，有效数位是 16 位，但在我的电脑且 VC++6.0 平台中默认显示同样是 6 位有效数字
例子：在 C 和 C++ 中，如下赋值语句:
float a=0.1;
编译器报错：warning C4305: ‘initializing’ : truncation from 'const double ’ to 'float ’
原因： 在 C/C++ 中（也不知道是不是就在 VC++ 中这样），上述语句等号右边 0.1，我们以为它是个 float，但是编译器却把它认为是个 double（因为小数默认是 double），所以要报这个 warning,一般改成 0.1f 就没事了。
本人通常的做法，经常使用 double，而不喜欢使用 float。
C 语言和 C# 语言中，对于浮点类型的数据采用单精度类型 float 和双精度类型 double 来存储，float 数据占用 32bit, double 数据占用 64bit,我们在声明一个变量 float f= 2.25f 的时候，是如何分配内存的呢？如果胡乱分配，那世界岂不是乱套了么，其实不论是 float 还是 double 在存储方式上都是遵从 IEEE 的规范 的，float 遵从的是 IEEE R32.24 ,而 double 遵从的是 R64.53。
无论是单精度还是双精度在存储中都分为三个部分：
1.符号位(Sign)：0 代表正，1 代表为负。
2.指数位(Exponent)：用于存储科学计数法中的指数数据，并且采用移位存储。
3.尾数部分(Mantissa)：尾数部分。

取余运算符：%
先看代码：

#include<iostream>
using namespace std;
int main() {
    int ge,shi,n;
    cin>>n;
    shi=n/10;
    ge=n%10;
    cout<<g*10+shi;
    return 0;
}
1
2
3
4
5
6
7
8
9
10
这是一个讲个位和十位交换的代码
6、7行是不是看不懂呀！

6：shi=n/10;的意思是把n除以十的商赋值给shi
7：ge=n%10;的意思是把n除以十的余数赋值给ge
在数学中‘%’是百分号如100%相当于1
c++中‘%’是取余运算符，也叫模运算符，例如：
15%2的值是1
14%2的值是0
38%10的值是8

ASILL码
(自己解释不清楚，引用部分转载一下：https://baike.so.com/doc/7103239-7326232.html)

ASCII(American Standard Code for Information Interchange，美国标准信息交换代码)是基于拉丁字母的一套电脑编码系统，主要用于显示现代英语和其他西欧语言。它是现今最通用的单字节编码系统，并等同于国际标准ISO/IEC 646。
请注意，ASCII是American Standard Code for Information Interchange缩写，而不是ASC2，有很多人在这个地方产生误解。

重要字符ASICC码表（不是全部，可以以此类推）：

字符    ASICC值
空格    32
0    48
9    57
A    65
Z    90
a    97
z    122
字符型char
字符型是以ASCII码存储的,它的存储形式就与整数的存储形式类似。
字符型质保函一个字符，用一对单引号括起来，如：‘+’,‘a’,‘7’,‘#’,'@'等，用char定义。

题目：输入一个小写字母，输出他相对的大写字母；
讲解：字符A的ASCII码值是65，a是97，两者相差32。
代码：

#include<iostream>
using namespace std;
int main() {
    char n;
    cin>>n;
    n-=32;//相当于n=n-32
    cout<<n;
    return 0;
}
1
2
3
4
5
6
7
8
9
输出：a
输出：A

2.选择结构
if语句
在日常生活中，有许多判断，如成绩大于等于60时为及格，一个数是2的倍数时为偶数……
像n>=60,n%2==0,称为关系运算符，如下：

>//大于
>=//大于等于
==//等于
<=//小于等于
<//小于
!=//不等于
1
2
3
4
5
6
关系表达式的值是一个逻辑值，即’真’或’假’。
如果条件成立，值为’真’，相对，值为’假’。
c++中，'真’表示非0，'假’表示0。
if语句的格式（1）：

if(表达式） 语句;
1
if语句的格式（2）：

if(表达式）{
  语句1;
  语句2;
  ……;
  语句n;
}
1
2
3
4
5
6
例题：
输入一个人的智商（IQ），如果>140，输出“天才”。
代码：

#include<iostream>
using namespace std;
int main() {
    int IQ;
    cin>>IQ;
    if(IQ>140) cout<<"天才"；
    return 0;
}
1
2
3
4
5
6
7
8
运行结果：
①
输入：141
输出：天才
②
输出：1
（无输出）

if-else语句
if语句格式（3）：

if(表达式1)
  语句1;
else
  语句2;
1
2
3
4
if：如果
else：否则
解释：
如果满足表达式1，执行语句1
如果不满足表达式1，执行语句2。

string字符串类型简单了解
先看代码：

#include<iostream>
#include<string>//string类型头文件
using namespace std;
int main() {
    string a="Minecraft__Himyyds";
    cout<<a;
    return 0;
}
1
2
3
4
5
6
7
8
输出:
Minecraft__Himyyds
解析：
字符串是夹在双引号里的一串字符，个数可以是0、1或多个。
如：“”,“1”,“114514”,“yyds”,"Minecraft__Him"等都是字符串，使用时必须引入头文件：

#include<string>
1
const常量
const的格式：

const 数据类型 变量名=值;
1
在定义变量时，如果加上关键字：const,则变量的值就无法改变，否则编译错误，这种变量称为常量，在c++中，常量又称只读变量。

比如：

#include<iostream>
#include<string>
using namespace std;
int main() {
    const string IOKIOI="IOKIOI!";
    string a;
    a=IOKIOI;
    cout<<a;
    return 0;
}
1
2
3
4
5
6
7
8
9
10
输出：
IOKIOI!

逻辑变量bool
bool是一种数据类型，它只有两个值：false（0（假）），true（1（真））。
例1：

#include<iostream>
using namespace std;
int main() {
    bool a=true;
    cout<<a;
    return 0;
}
1
2
3
4
5
6
7
运行结果：
1

例2：

#include<iostream>
using namespace std;
int main() {
    bool a=false;
    cout<<a;
    return 0;
}
1
2
3
4
5
6
7
运行结果：
0

逻辑运算符
题目：
输入一个数，如果是3和5的公倍数，输出YES，否则输出NO
代码：

#include<iostream>
using namespace std;
int main() {
    int n;
    cin>>n;
    if(n%3==0&&n%5==0){
      cout<<"YES";
    }
    else{
      cout<<"NO";
    }
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
讲解：

这个问题有2个条件：能被3整除，能被5整除，即n%3=0,n%5=0都要满足，这是要用到表示“而且”的逻辑运算符&&（逻辑与），代码为：

n%3==0&&n%5==0;
1
逻辑运算符有3个：

逻辑运算符    名字
&&    逻辑与
两根竖线（Markdown显示不出来）    逻辑或
!    逻辑非
逻辑运算符的优先级
非的级别最高，或的级别最低
即:

!→&&→||

附和语句
两个数按从小到大顺序
代码：

#include<iostream>
using namespace std;
int main() {
    int a,b,t;
    cin>>a>>b;
    if(a>b){//交换
      t=a;
      a=b;
      b=t;  
    }
    cout<<a<<" "<<b;
    return 0;
}    
1
2
3
4
5
6
7
8
9
10
11
12
13
输入：
10 20
输出：
10 20

两个数按从大到小顺序
代码：

#include<iostream>
using namespace std;
int main() {
    int a,b,t;
    cin>>a>>b;
    if(a<b){//交换
      t=a;
      a=b;
      b=t;  
    }
    cout<<a<<" "<<b;
    return 0;
}    
1
2
3
4
5
6
7
8
9
10
11
12
13
输入：
10 20
输出：
20 10