目录
1、输出hello world
#include<iostream>
using namespace std;
int main()
{
cout << "hello world!" << endl;
return 0;
}std::cout流来输出文本信息。其中<<是输出运算符，它用来将文本信息插入到输出流中。"hello world!"是要输出的文本信息，std::endl是表示插入换行符的操作符，它会在输出文本的末尾插入一个换行符，使得输出的文本在控制台上单独占据一行。最终执行该代码会在控制台上输出"hello world!"并换行。
一、变量和数据类型
1、变量
想要使用变量，必须先做“声明”，也就是告诉计算机要用到的数据叫什么名字，同时还要指明保存数据所需要的空间大小。比如: int a;
这里包含两个信息:一个是变量的名字，叫做“a”，它对应着计算机内存中的一个位置;另一个是变量占据的空间大小，这是通过前面的“int”来指明的，表示我们需要足够的空间来存放一个“整数类型”( integer）数据。
变量声明： 数据类型 变量名；
#include<iostream>
using namespace std;
int main()
{
int a = 10, b;
cout << "a = " << a << endl;
b = 20;
cout << "b = " << b << endl;
//cin.get();//等待键盘输入
}运行结果：
2、标识符
每个变量都有一个名字，就是所谓的“变量名”。在C++中，变量、函数、类都可以有自己专门的名字，这些名字被叫做“标识符”。
标识符由字母、数字和下划线组成;不能以数字开头;标识符是大小写敏感的，长度不限。
例如： int a; char name;
标识符命名要求：
不能使用C++关键字;
不能用连续两个下划线开头，也不能以下划线加大写字母开头，这些被C++保留给标准库使用;
函数体外的标识符，不能以下划线开头;
要尽量有实际意义（不要定义a、b，而要定义name、age);变量名一般使用小写字母;
自定义类名一般以大写字母开头;
如果包含多个单词，一般用下划线分隔，或者将后面的单词首字母大写;
3、作用域
在C++中，有“作用域”(scope）的概念，就是指程序中的某一段、某一部分。一般作用域都是以花括号{}作为分隔的，就像之前我们看到的函数体那样。
同一个名字在本同的作用域中,可以指代不同的实体(变量、函数、类等等)。定义在所有花括号外的名字具有“全局作用域”(global scope)，而在某个花括号内定义的名字具有“块作用域”。一般把具有全局作用域的变量叫做“全局变量”，具有块作用域的变量叫做“局部变量”。
#include<iostream>
using namespace std;
int number = 0; //全局变量
int main()
{
int number = 666; //局部变量
cout << "number = " << number << endl;
}全局变量和局部变量同名的时候会输出什么样的结果？可以思考一下哟
输出结果：
为什么输出的是666，而不是0呢？输出结果是以作用域更小的为准，就相当于局部变量覆盖了全局变量。那新的问题来了，那我想使用全部变量怎么办呢？
4、常量
用变量可以灵活地保存数据、访问数据。不过有的时候，我们希望保存的数据不能更改，这种特殊的变量就被叫做“常量”。在C++中，有两种方式可以定义常量:
(1）使用符号常量 这种方式是在文件头用#define来定义常量，也叫作“宏定义”。
define PI 3.14
跟#include一样，井号“#”开头的语句都是“预处理语句”，在编译之前，预处理器会查找程序中所有的“PI"，并把它替换成3.14。这种宏定义的方式是保留的c语言特性，在C++中一般不推荐。
(2）使用const限定符
这种方式跟定义一个变量是一样的,只需要在变量的数据类型前再加上一个const关键字，这被称为“限定符”。
//定义常量
const float Pi = 3.14; //不能修改常量值，只能初始化一次
const修饰的对象一旦创建就不能改变，所以必须初始化。
跟使用#define定义宏常量相比，const定义的常量有详细的数据类型，而且会在编译阶段进行安全检查，在运行时才完成替换，所以会更加安全和方便。
#include<iostream>
using namespace std;
int main()
{
const float Pi = 3.14; //常量
cout << "Pi = " << Pi << endl;
}输出结果：
5、数据类型
1.基本数据类型-整型
C++定义的基本整型包括char、 short、int、long，和C++11新增的long long类型，此外特殊的布尔类型bool本质上也是整型。
short类型至少为16位（2字节)int至少2字节，而且不能比 short短long至少4字节，而且不能比int短，long long至少8字节，而且不能比 long短。
现在一般系统中，short和 long 都选择最小长度，也就是short为16位、long为32位、long long 为64位;而int则有不同选择。我们一般使用的电脑操作系统，比如 Windows 7、Windows 10、Mac Os等等的实现中，int 都是32位的。
#include<iostream>
using namespace std;
int main()
{
short a = 666;
int b = 888;
long c = 1;
long long d = 2;
cout << "a = " << a << endl;
cout << "b = " << b << endl;
cout << "c = " << c << endl;
cout << "d = " << d << endl;
cout << "a的类型大小：" << sizeof a << endl;
cout << "b的类型大小：" << sizeof b << endl;
cout << "c的类型大小：" << sizeof c << endl;
cout << "d的类型大小：" << sizeof d << endl;
}运行结果：
2.char类型
最常用的字符编码集就是ASCII码，它用0~127表示了128个字符，这包括了所有的大小写字母、数字、标点符号、特殊符号以及一些计算机的控制符。比如字母“A”的编码是65,I数字字符“o”的编码是48。
在程序中如果使用char类型的变量,我们会发现,打印出来就是一个字符;而它的底层是一个整数，也可以做整数计算。
#include<iostream>
using namespace std;
int main()
{
char a = 65;
char b = a + 1;
cout << "a = " << a << endl;
cout << "a+1 = " << (a+1) << endl;
cout << "b = " << b << endl;
cin.get();
}运行结果：
3.bool类型
在程序中，往往需要针对某个条件做判断，结果只有两种:“成立”和“不成立”;如果用逻辑语言来描述，就是“真”和“假”。真值判断是二元的，所以在c语言中，可以很简单地用“1”表示“真”，fo”表示“假”。
C++支持c语言中的这种定义，同时为了让代码更容易理解，引入了一种新的数据类型——布尔类型bool。bool类型只有两个取值: true和 false，这样就可以非常明确地表示逻辑真假了。bool类型通常占用8位（1个字节)。
#include<iostream>
using namespace std;
int main()
{
bool b = true;
cout << "b = " << b << endl;
cout << "b占据长度为： " << sizeof b << endl;
cin.get();
}运行结果：
4.浮点类型
跟整数对应，浮点数用来表示小数，主要有单精度float和双精度double 两种类型，double的长度不会小于float。通常，float会占用4个字节(32位)，而double会占用8个字节(64位)。此外，C++还提供了一种扩展的高精度类型longdouble，一般会占12或16个字节。|
除了一般的小数，在C++中，还提供了另外一种浮点数的表示法，那就是科学计数法，也叫作“E表示法”。比如:5.98E24表示5.98×10的24次方;9.11e-31表示9.11×10的－31次方。
#include<iostream>
using namespace std;
int main()
{
float a = 1.23;
double b = 1.23e3;
cout << "b = " << b << endl;
cout << "a = " << a << endl;
cin.get();
}运行结果：
5.字面值常量
(1）整型字面值
整型字面值就是我们直接写的一个整数，比如 30。这是一个十进制数。而计算机底层是二进制的,所以还支持我们把一个数写成八进制和十六进制的形式。以0开头的整数表示八进制数;以0x或者0X开头的代表十六进制数。例如:
30十进制数
036八进制数
0x1E 十六进制数
这几个数本质上都是十进制的30，在计算机底层都是一样的。
在C++中，一个整型字面值，默认就是int类型，前提是数值在int能表示的范围内。如果超出int范围，那么就需要选择能够表示这个数的、长度最小的那个类型。
具体来说，对于十进制整型字面值，如果int不够那么选择long;还不够，就选择long long（不考虑无将号类型);而八进制和十六进制字面值，则会优先用无符号类型unsigned int,不够的话再选择long,之后依次是unsigned long、longlong和 unsigned long long。
这看起来非常复杂，很容易出现莫名其妙的错误。所以一般我们在定义整型字面值时，会给它加上一个后缀，明确地告诉计算机这个字面值是什么类型。
默认什么都不加，是int类型;
l或者L，表示long 类型;
II或者LL，表示long long类型;
u或者u，表示unsigned无符号类型;
我们一般会用大写L，避免跟数字1混淆;而u可以和i或LL组合使用。例如9527uLL就表示这个数是unsigned long long类型。
(2）浮点型字面值
前面已经提到，可以用一般的小数或者科学计数法表示的数，来给浮点类型赋值，这样的数就都是“浮点型字面值”。浮点型字面值默认的类型是double。如果我们希望明确指定类型，也可以加上相应的后缀:
f或者F，表示float类型
I或者L，表示long double类型
这里因为本身数值是小数或者科学计数法表示，所以工不会跟long 类型混淆。
(3）字符和字符串字面值
字符就是我们所说的字母、单个数字或者符号,字面值用单引号引起来表示。字符字面值默认的类型就是char，底层存储也是整型。
而多个字符组合在一起，就构成了“字符串”。字符串字面值是一串字符，用双引号引起来表示。
‘A’字符字面值 ， "Hello World!”字符串字面值
转义字符
有一类比较特殊的字符字面值，我们是不能直接使用的。在ASCll码中我们看到，除去字母、数字外还有很多符号，其中有一些本身在C++语法中有特殊的用途，比如单引号和双引号;另外还有一些控制字符。如果我们想要使用它们，就需要进行“转义”，这就是“转义字符”。
二、运算符
1、算数运算符
这里需要注意的是，同一个运算符，在不同的场合可能表达不同的含义。比如“一”，可以是“减号”也可以是“负号”:如果直接放在一个表达式前面，就是对表达式的结果取负数，这是一元运算符;如果连接两个表达式，就是两者结果相减，是二元运算符。
#include<iostream>
using namespace std;
int main()
{
//算数运算符
cout << "1 + 2 = " << 1 + 2 << endl;
cout << "1 + 2 * 3 - 4 = " << 1 + 2 * 3 - 4 << endl;
int a = 2, b = 4, c = 7;
cout << "a + b = " << a + b << endl;
cout << "a * b + c = " << a * b + c << endl;
cout << "c / a = " << c / a << endl; //两个整型数相除，结果还是整数
float d = 10;
cout << "d / b = " << d / b << endl; //小数和整数相除，结果是小数
cout << "c % b = " << c % b << endl; //取模运算只能用于整数
cout << "-c % b = " << -c % b << endl;
cin.get();
}运算结果：
2、赋值运算符
在C++中，用等号“=”表示一个赋值操作，这里的“=”就是赋值运算符。需要注意的是，赋值运算符的左边，必须是一个可修改的数据对象，比如假设我们已经定义了一个int类型的变量a，那么
a = 1; 这就是赋值。
赋值运算有以下一些规则:
赋值运算的结果，就是它左侧的运算对象;结果的类型就是左侧运算对象的类型;
如果赋值运算符两侧对象类型不同，就把右侧的对象转换成左侧对象的类型;
C++11新标准提供了一种新的语法:用花括号括起来的数值列表，可以作为赋值右侧对象。这样就可以非常方便地对一个数组赋值了;赋值运算满足右结合律。也就是说可以在一条语句中连续赋值，结合顺序是从右到左;
赋值运算符优先级较低，一般都会先执行其它运算符，最后做赋值;
3、复合赋值运算符
实际应用中，我们经常需要把一次计算的结果，再赋值给参与运算的某一个变量。最简单的例子就是多个数求和，比如我们要计算a、b、c的和，那么可以专门定义一个变量sum，用来保存求和结果:
常见的C++复合运算符包括：
- += ：a += b 表示将a和b相加，并将结果赋给a
- -= ：a -= b 表示将a减去b，并将结果赋给a
- *= ：a *= b 表示将a和b相乘，并将结果赋给a
- /= ：a /= b 表示将a除以b，并将结果赋给a
- %= ：a %= b 表示a对b取余，并将结果赋给a
4、关系和逻辑运算
1.关系运算符 -------结果是一个bool值
这里要注意区分的是，在C++语法中一个等号“=”表示的是赋值，两个等号“==”才是真正的“等于”。
关系运算符的相关规则:
算术运算符的优先级高于关系运算符，而如果加上括号就可以调整计算顺序;
关系运算符的返回值为布尔类型，如果参与算术计算，true的值为1，false的值为0;
#include<iostream>
using namespace std;
int main()
{
//关系运算符
int a = 1, b = 2, c = 3;
cout << "a < b ：" << (a < b) << endl;
cout << "c == a + b ：" << (c ==(a + b)) << endl;
cin.get();
}运算结果：
2.逻辑运算符
一个关系运算符的结果是一个布尔类型（ture或者false)，就可以表示一个条件的判断;如果需要多个条件的叠加，就可以用逻辑“与或非”将这些布尔类型组合起来。这样的运算符叫做“逻辑运算符”。
逻辑非（ !):一元运算符，将运算对象的值取反后返回，真值反转;
逻辑与（&&):二元运算符，两个运算对象都为 true时结果为true，否则结果为false;
逻辑或(|):二元运算符，两个运算对象只要有一个为 true 结果就为true，都为false则结果为false;
#include<iostream>
using namespace std;
int main()
{
//逻辑运算符
int a = 1, b = 2, c = 3;
cout << "a < b && c > 5 ：" << (a < b && c > 5) << endl;
cout << "a < b || c > 5 ：" << (a < b || c > 5) << endl;
cin.get();
}运行结果：
这里需要注意的规则有:
如果将一个算术类型的对象作为逻辑运算符的操作数，那么值为О表示false，非o值表示true;
逻辑与和逻辑或有两个运算对象，在计算时都是先求左侧对象的值，再求右侧对象的值;如果左侧对象的值已经能决定最终绪果，那么右侧就不会执行计算:这种策略叫做“短路求值”;
#include<iostream>
using namespace std;
int main()
{
//短路求值
int i = 0,j = 0;
1 < 2 && ++i;
cout << "i = " << i << endl;
1 < 2 || ++j;
cout << "j = " << j << endl;
cin.get();
}运行结果：
3.条件运算符
C++还从C语言继承了一个特殊的运算符，叫做“条件运算符”。它由“?”和“:”两个符号组成，需要三个运算表达式，形式如下:
条件判断表达式?表达式1∶表达式2
它的含义是:计算条件判断表达式的值，如果为true就执行表达式1，返回求值结果;如果为false 则跳过表达式1，执行表达式2，返回求值结果。这也是C++中唯一的一个三元运算符。
#include<iostream>
using namespace std;
int main()
{
//条件运算符
int i = 0;
int a = 5, b = 2, max;
cout << (1 < 2 && ++i ? "true" : "false") << endl;
cout << "max = " << ((a > b) ? a : b) << endl;
cin.get();
}运行结果：
5、位运算符
之前介绍的所有运算符，主要都是针对算术类型的数据对象进行操作的;所有的算术类型，占用的空间都是以字节(byte，8位)作为单位来衡量的。在C++中，还有一类非常底层的运算符，可以直接操作到具体的每一位（bit）数据，这就是“位运算符”。
位运算符可以分为两大类:移位运算符，和位逻辑运算符。下面列出了所有位运算符的优先级和用法。
1.移位运算符
移位运算符有两种:左移运算符“<<”和右移运算符“>>”。
#include<iostream>
using namespace std;
int main()
{
//位运算符
unsigned char bits = 0xA8; //10101000
cout << hex;
cout << "bits右移2位：" << (bits >> 2) << endl; //0010 1010
cin.get();
}运行结果：
2.位逻辑运算符
计算机存储的每一个“位”(bit）都是二进制的，有0和1两种取值，这跟布尔类型的真值表达非常类似。于是自然可以想到，两个位上的“O”或“1”都可以执行类似逻辑运算的操作。
位逻辑运算符有:按位取反“~”，位与“&”，位或“|”和位异或“^”。
按位取反“~”:一元运算符，类似逻辑非。对每个位取反值，也就是把1置为0、0置为1;
位与“&”:二元运算符，类似逻辑与。两个数对应位上都为1，结果对应位为1;否则结果对应位为0;
位或“|”:二元运算符，类似逻辑或。两个数对应位上只要有1，结果对应位就为1;如果全为О则结果对应位为0;
位异或“^”:两个数对应位相同，则结果对应位为0;不同则结果对应位为0;
三、流程控制语句
1、条件分支
C++提供了两种按条件分支执行的控制语句:if 和switch。
1.if
if 语句主要就是判断一个条件是否为真(true),如果为真就执行下面的语句，如果为假则跳过。具体形式可以分为两种:一种是单独一个if，一般称为“单分支”;另一种是if ... else ...，称为“双分支”。
(1)单分支
单分支是最简单的if用法，判断的条件用小括号括起来跟在if后面，然后是如果条件为真要执行的语句。基本形式为:
#include<iostream>
using namespace std;
int main()
{
//输入用户年龄，判断后显示欢迎信息
cout << "请输入您的年龄：" << endl;
int age;
cin >> age;
cin.get();
if (age >= 18)
{
cout << "欢迎登录" << endl;
}
else
cout << "少儿不宜" << endl;
cin.get();
}运行结果：
(2）嵌套分支（多分支)
程序中的分支有可能不只两个，这时就需要对if分支或者else分支再做条件判断和拆分了，这就是“嵌套分支”。
#include<iostream>
using namespace std;
int main()
{
//输入用户年龄，判断后显示欢迎信息
cout << "请输入您的年龄：" << endl;
int age;
cin >> age;
cin.get();
if (age >= 18)
{
cout << "欢迎登录" << endl;
if(age < 35)
{
cout << "继续加油，年轻人" << endl;
}
}
else
{
cout << "少儿不宜" << endl;
if (age >= 12)
{
cout << "少年，好好学习" << endl;
}
else
cout << "小朋友，别乱玩" << endl;
}
cin.get();
}运行结果：
嵌套分支如果比较多，代码的可读性会大幅降低。所以还有一种更加简单的嵌套分支写法，那就是if ... else if ..，具体形式如下:
#include<iostream>
using namespace std;
int main()
{
//输入用户年龄，判断后显示欢迎信息
cout << "请输入您的年龄：" << endl;
int age;
cin >> age;
cin.get();
if(age < 12)
{
cout << "小朋友，别乱玩" << endl;
}
else if (age < 18)
{
cout << "少年，好好学习" << endl;
}
else if (age < 35)
{
cout << "好好玩" << endl;
}
else if (age < 60)
{
cout << "继续加油，中轻人" << endl;
}
else
{
cout << "好好休息" << endl;
}
cin.get();
}运行结果:
2.switch
这里switch后面的括号里是一个表达式，对它求值，然后转换成整数类型跟下面每个case后面的值做比较;如果相等，就进入这个case指定的分支，执行后面的语句，直到swith 语句结束或者遇到break退出。需要注意的是:
case关键字和后面对应的值，合起来叫做一个“case标签”; case标签必须是一个整型的常量表达式;
任何两个case标签不能相同;
break语句的作用是“中断”，会直接跳转到switch语句结构的外面;
如果没有break 语句，那么匹配某个case标签之后，程序会从上到下一直执行下去;这会执行多个标签下面的语句，可能发生错误;
如果没有匹配上任何case标签的值，程序会执行default标签后面的语句; default是可选的，表示“默认要执行的操作”。
#include<iostream>
using namespace std;
int main()
{
cout << "请输入您的成绩" << endl;
char score;
cin >> score;
cin.get();
switch (score)
{
case 'A':
cout << "你真棒，获得优秀的成绩" << endl; break;
case 'B':
cout << "良好" << endl; break;
case 'C':
cout << "中等" << endl; break;
case 'D':
cout << "加油吧" << endl; break;
default:
break;
}
cin.get();
}运行结果：
2、循环
C++中的循环语句，有while、do while和 for三种。
1.while
while只需要给定一个判断条件，只要条件为真，就重复地执行语句。形式如下:
要执行的语句往往会有多条，这就需要用花括号将它们括起来。这个块一般被称为“循环体”。
一般来说，用来控制while循环的条件中一定会包含变量，通常叫做“循环变量”;而它或者在条件中变化，或者在循环体中变化，这样才能保证循环能够终止退出。
#include<iostream>
using namespace std;
int main()
{
cout << "循环即将开始...\n" << endl;
int i = 1;
while (i <= 10)
{
cout << "现在是第" << i << "循环" << endl;
++i;
}
cin.get();
}运行结果：
2.do while
do while和 while非常类似，区别在于do while是先执行循环体中的语句，然后再检查条件是否满足。所以do while至少会执行一次循环体。
do while语法形式如下:
#include<iostream>
using namespace std;
int main()
{
cout << "循环即将开始...\n" << endl;
int i = 1;
while (i <= 10)
{
cout << "现在是第" << i << "循环" << endl;
++i;
}
cout << "-------------------------" << endl;
do
{
cout << "现在是倒数" << --i << "次循环" << endl;
} while (i > 1);
cin.get();
}运行结果：
3.for
for循环的经典语法形式是:
关键字for和它后面括号里的部分，叫做“for语句头”。for语句头中有三部分，用分号分隔，主要作用是:
初始化语句负责初始化一个变量，这个变量值会随着循环迭代而改变，一般就是“循环变量”:
中间的条件是控制循环执行的关键，为真则执行下面的循环体语句，为假则退出。条件一般会以循环变量作为判断标准;
最后的表达式会在本次循环完成之后再执行，一般会对循环变量进行更改;
这三个部分并不是必要的，根据需要都可以进行省略。如果省略某个部分，需要保留分号表示这是一个空语句。
#include<iostream>
using namespace std;
int main()
{
cout << "循环即将开始..." << endl;
for (int i = 1; i <= 10; i++)
{
cout << "hello " << i << endl;
}
cout << "循环结束" << endl;
cin.get();
}运行结果：
九九乘法表例程：
#include<iostream>
using namespace std;
int main()
{
//使用嵌套for循环实现九九乘法表
//i:行号，j:列号
for (int i = 1; i <= 9; i++)
{
for (int j = 1; j <= i; j++)
{
cout << i << "*" << j << "=" << i * j << "\t";
}
cout << endl;
}
cin.get();
}运行结果：
3、跳转
在流程控制语句中还有一类“跳转语句”，主要用来中断当前的执行过程。C++中有四种跳转语句: break，continue，goto 以及return 0；
1.break
#include<iostream>
using namespace std;
int main()
{
int i = 1;
while (true)
{
cout << "hello world,i = " << i++ << endl;
if (i > 5)
{
break;
}
}
cin.get();
}运行结果：
2.continue
continue语句表示“继续”执行循环，也就是中断循环中的本次迭代、并开始执行下一次迭代。很明显，continue只能用在循环语句中，同样针对最近的一层循环有效。
#include<iostream>
using namespace std;
int main()
{
//逢7过
for (int num = 1; num <= 100; num++)
{
cout << "\t";
//如果是7的倍数或者含7就跳过
if (num % 7 == 0 || num % 10 == 7 || num / 10 == 7)
continue;
cout << num;
//如果是10的倍数，则换行
if (num % 10 == 0)
{
cout << endl << endl;
}
}
cin.get();
}运行结果：
3.goto
goto语句表示无条件地跳转到程序中的另一条语句。goto的语法形式为:
这里的“标签”可以认为是一条语句的“名字”，跟变量类似，只不过它是指代一条语句的标识符。定义标签也非常简单，只要在一条语句前写出标识符，然后跟上冒号就可以了，比如:
#include<iostream>
using namespace std;
int main()
{
int i = 1;
p1:
do
{
cout << "i = " << ++i << endl;
} while (i < 10);
if (i < 15)
{
goto p1;
}
cin.get();
}运行结果：
