• 小白开始学习C++

    ​​​​第一节：控制台输出hello word！

    #include  //引入库文件

    int main()
    {
        //控制台输出 hello word! 之后回车
        std::cout << "hello word!\n";  

    1. #include  //引入库文件
    2.  
    3. int main()
    4. {
    5. 	//控制台输出 hello word! 之后回车
    6. 	std::cout << "hello word!\n";  
    7. }

    }

    • 第二节 多个字符串组合输出

    #include

    using namespace std;      //这么写省略了输出时的std。

    int main()
    {

        //std::cout 中的std::省略了
        cout << "姓名："
            << " 貂蝉 "
            << " 年龄："
            << 18
            << " 体重："
            << "75KG "
            << " 苗条"
            << endl;
    }

    1. #include
    2.  
    3. using namespace std;
    4.  
    5. int main()
    6. {
    7. 	cout << "姓名："
    8. 		<< " 貂蝉 "
    9. 		<< " 年龄："
    10. 		<< 18
    11. 		<< " 体重："
    12. 		<< "75KG "
    13. 		<< " 苗条"
    14. 		<< endl;
    15. }

    • 第三节 变量的创建和字符串拼接输出

    #include

    using namespace std;

    int main()
    {
        //整数（int）、浮点数（float和double）、字符（char）、字符串（string）和布尔（bool）
        //姓名、年龄、体重、性别、颜值。
        
        //声明变量，存放这些信息。
        string name;      // 姓名， string什么样的值都能放入
        int age;          // 年龄， 放入整型数据
        double weight;    // 体重，放入双精度小数
        char sex;         // 性别，X-女，Y-男
        bool yz;          // 颜值： true-漂亮， false-不漂亮。

        name = "貂蝉";
        age = 21;
        weight = 56.34;
        sex = 'X';
        yz = true;

        //输出拼接字符串插入变量
        cout << "姓名：" << name
            << "年龄：" << age
            << "体重：" << weight << "KG "
            << "性别：" << sex
            << "颜值：" << yz
            << endl;
    }

    1. #include
    2.  
    3. using namespace std;
    4.  
    5. int main()
    6. {
    7. 	//整数（int）、浮点数（float和double）、字符（char）、字符串（string）和布尔（bool）
    8. 	//姓名、年龄、体重、性别、颜值。
    9. 	
    10. 	//声明变量，存放这些信息。
    11. 	string name;      // 姓名， string什么样的值都能放入
    12. 	int age;          // 年龄， 放入整型数据
    13. 	double weight;    // 体重，放入双精度小数
    14. 	char sex;         // 性别，X-女，Y-男
    15. 	bool yz;          // 颜值： true-漂亮， false-不漂亮。
    16.  
    17. 	name = "貂蝉";
    18. 	age = 21;
    19. 	weight = 56.34;
    20. 	sex = 'X';
    21. 	yz = true;
    22.  
    23. 	//输出拼接字符串插入变量
    24. 	cout << "姓名：" << name
    25. 		<< "年龄：" << age
    26. 		<< "体重：" << weight << "KG "
    27. 		<< "性别：" << sex
    28. 		<< "颜值：" << yz
    29. 		<< endl;
    30. }

    • 第四节 常量的使用

    1、宏常量

    语法：#define 常量名 值

    2、const修饰的变量

    语法：const 变量名=值；

    1. #include
    2.  
    3. using namespace std;
    4.  
    5. #define MONTHS 12//                          宏常量   #define 常量名 值
    6. #define PI 3.1415926//                       宏常量   #define 常量名 值
    7.  
    8. int main()
    9. {
    10. 	const int week = 7;                   // const 修饰的常变量
    11. 	cout << "一年有："<
    12. 	cout << "圆周率是：" << PI << endl;
    13. }

    • 第五节 标识符的命名

    c++规定标识符（变量、常量、函数、结构体、类等）命名时，必须遵守以下规则。
    1、 在名称中只能使用字母字符、数字和下划线；
    2、 名称的第一个字符不能是数字；
    3、区分大写字符和小写字符；
    4、不能将c++关键字用作名称；
    5、以下划线和大写字母打头的名称被保留给编译器极其使用的资源使用，如果违反这一规则，会导致行为的不确定性。
    6、  c++对名称的长度没有限制，但有些平台可能有长度限制。

    • 第六节 数据输入

    数据输入
        语法：std::cin>>变量名
        注意：
        布尔型变量输入时只能填0或非0，非0转换成1；
        如果输入的类型与变量的数据类型不匹配，会导致行为的不确定性。

    1. #include
    2. using namespace std;
    3. int main()
    4. {
    5. 	string name;
    6. 	cout << "请输入你的姓名：";
    7. 	cin >> name;
    8. 	cout << "刚刚输入的姓名是：" << name << endl;
    9.  
    10.  
    11. 	return 0;
    12. }

    •  第七节 算术运算

    算术运算
        +      两个数相加
        -      一个数减另一个数
        *      两个数相乘
        /      一个数除以另一个数
        %      取模运算符，整除后的余数

        注意：
        整数进行除法运算时，如果分母为0，程序将异常退出；
        浮点数进行除法运算时，如果分母为0.0，将得到inf（nfinite，无穷大）；
        两个整数进行除法运算时，将舍弃小数部分，得到一个整数；
        整数与浮点数进行除法运算时，得到的结果是浮点数；
        在整数前面加（float）或（double）可以将整数转换成float或double类型
        取模运算只能用于整数（分母不能为0）

    1. #include
    2.  
    3.  
    4. using namespace std;
    5.  
    6. int main()
    7. {
    8. 	int a=8;
    9. 	int b=2;
    10.  
    11. 	//整数进行除法运算时，如果分母为0，程序将异常退出；
    12. 	//cout << a / 0 << endl;  
    13.  
    14. 	//浮点数进行除法运算时，如果分母为0.0，将得到inf（nfinite，无穷大）；
    15. 	cout << (float)a / 0.0 << endl;  //结果：inf
    16.  
    17. 	//两个整数进行除法运算时，将舍弃小数部分，得到一个整数；
    18. 	cout << a / 3 << endl;        //结果：2
    19.  
    20. 	//整数与浮点数进行除法运算时，得到的结果是浮点数；
    21. 	cout << a / 2.5 << endl;     //结果：3.2
    22.  
    23. 	//在整数前面加（float）或（double）可以将整数转换成float或double类型
    24. 	cout << (double)a / (double)2.5 << endl;    // 结果：3.2
    25.  
    26. 	//取模运算只能用于整数（分母不能为0）
    27. 	cout << a % 3 << endl;    //结果：2
    28.  
    29. 	cout << a + b << endl;    //结果：10
    30.  
    31. 	cout << a * b << endl;    //结果：16
    32.  
    33. 	cout << a - b << endl;    //结果：6
    34. }

    • 第八节  自增和自减

        ++变量名       先把变量值加1，然后再执行表达式。
        变量名++       先执行表达式，再把变量的值+1.
        --变量名       先把变量值-1，然后再执行表达式。
        变量名--       先执行表达式，再把变量值-1.

    1. #include
    2.  
    3. using namespace std;
    4.  
    5. int main()
    6. {
    7. 	int i = 10;
    8. 	int a = 0;
    9.  
    10. 	//先执行表达式，再把变量的值 + 1.
    11. 	a = i++;
    12. 	cout << "a=" << a << endl;  //结果：a=10
    13. 	cout << "i=" << i << endl;  //结果：i=11
    14. 	cout << endl;   //换行
    15.  
    16. 	//先把变量值加1，然后再执行表达式。
    17. 	a = ++i;
    18. 	cout << "a=" << a << endl;  //结果：a=12
    19. 	cout << "i=" << i << endl;  //结果：i=12
    20. 	cout << endl;   //换行
    21.  
    22. 	//先把变量值 - 1，然后再执行表达式。
    23. 	a = --i;
    24. 	cout << "a=" << a << endl;  //结果：a=11
    25. 	cout << "i=" << i << endl;  //结果：i=11
    26. 	cout << endl;    //换行
    27.  
    28. 	//先执行表达式，再把变量值-1.
    29. 	a = i--;
    30. 	cout << "a=" << a << endl;  //结果：a=11
    31. 	cout << "i=" << i << endl;  //结果：i=10
    32. }

    第九节   赋值运算

         =    c=a+b a+b的值赋给c     把右边操作数的值赋给左边操作数
        +=      c+=a  相当于c=c+a      加且赋值运算符，把右边操作数加上左边操作数的结果赋值给左边操作数。
        -=      a -= a 相当于c=c-a     减且赋值运算符，把左边操作数减去右边操作数的结果赋值给左边操作数。
        *=      c *= c  相当于c=c*a    乘且赋值运算符，把右边操作数乘以左边操作数的结果赋值给左边操作数。
        /=      c/=a   相当于 c= c/a   除且赋值运算符，把左边操作数除以右边操作数的结果赋值给左边操作数。
        %=      c%=a  相当于 c=c%a     求余数且赋值运算符，求两个操作数的模赋值给左边操作数，浮点数不适用取余数。

        注意：
            1、字符串（string）只能使用等号（=）赋值，不能使用其他的赋值运算符；
        2、浮点数不能使用%=运算符；
        3、 等号（=）赋值运算符可以连续使用；
        4、如果等号两边的操作数的数据类型不同，c++将自动转换数据类型，可能会损失精度，也可以超出取值范围，如果转换不成功，编译时会报错

    1. #include
    2.  
    3. using namespace std;
    4.  
    5. int main()
    6. {
    7. 	//=	c=a+b a+b的值赋给c     把右边操作数的值赋给左边操作数
    8. 	int a = 2, b = 3;
    9. 	int c = 0;
    10. 	c = a + b;
    11. 	cout << "c=" << c << endl;
    12.  
    13. 	//+=  c+=a  相当于c=c+a      加且赋值运算符，把右边操作数加上左边操作数的结果赋值给左边操作数。
    14. 	c += a;
    15. 	cout << "c=" << c << endl;
    16.  
    17. 	//-=  a -= a 相当于c=c-a     减且赋值运算符，把左边操作数减去右边操作数的结果赋值给左边操作数。
    18. 	c = 5;
    19. 	c -= a;
    20. 	cout << "c=" << c << endl;
    21.  
    22. 	// *=  c *= c  相当于c=c*a    乘且赋值运算符，把右边操作数乘以左边操作数的结果赋值给左边操作数。
    23. 	c = 2;
    24. 	c *= c;
    25. 	cout << "c=" << c << endl;
    26.  
    27. 	//   /=  c/=a   相当于 c= c/a   除且赋值运算符，把左边操作数除以右边操作数的结果赋值给左边操作数。
    28. 	c = 6;
    29. 	c /= a;
    30. 	cout << "c=" << c << endl;
    31.  
    32. 	//  %=  c%=a  相当于 c=c%a     求余数且赋值运算符，求两个操作数的模赋值给左边操作数，浮点数不适用取余数。
    33. 	c = 5;
    34. 	c %= a;
    35. 	cout << "c=" << c << endl;
    36. }

    • 第十节  C++11初始化赋值

    1、把值写在小括号中，等于号可以省略（c++标准）
            int a=(15)  //声明变量a，初始化值为15.
            int b(20)   //声明变量b，初始化值为20.

        2、把值写在花括号中，等于号也可以省略（c++11标准）统一初始化列表。
            int a={15}  // 声明变量a，初始化值为15.
            int b{20}   // 声明变量b，初始化值为20.

        注意：在linux平台下，编译需要加-std=c++11参数。

    1. #include
    2.  
    3. using namespace std;
    4.  
    5. int main()
    6. {
    7. 	int a = 2;
    8. 	int b(3);
    9. 	int c = (4);
    10. 	int d = 5;
    11. 	int e{ 6 };
    12. 	int f = { 7 };
    13.  
    14. 	cout << "a=" << a << endl;
    15. 	cout << "b=" << b << endl;
    16. 	cout << "c=" << c << endl;
    17. 	cout << "d=" << d << endl;
    18. 	cout << "e=" << e << endl;
    19. 	cout << "f=" << f << endl;
    20. }

    • 第十一节  关系运算

    用于表达两个表达式的值，运算的结果为1-true和0-false。

        ==  等于
        !=  不等于
        <   小于
        <=  小于等于
        >   大于
        >=  大于等于

        注意：
            1、关系运算符的两边可以是数值，也可以是表达式；
            2、用std::cout输出关系运算表达式时，要加括号；
            3、关系运算也适用于字符串（string）.

    1. #include
    2.  
    3. using namespace std;
    4.  
    5. int main()
    6. {
    7. 	int a(5), b(8);
    8. 	cout << (a == b) << "\n"
    9. 		<< (a + 3 == b) << endl;
    10.  
    11. 	cout << (a != b) << "\n"
    12. 		<< (a + 3 != b) << endl;
    13.  
    14. 	cout << (a < b) << "\n"
    15. 		<< (a + 4 < b) << endl;
    16.  
    17. 	cout << (a+4 <= b) << "\n"
    18. 		<< (a + 3 <= b) << endl;
    19.  
    20. 	cout << (a > b) << "\n"
    21. 		<< (a + 4 > b) << endl;
    22.  
    23. 	cout << (a >= b) << "\n"
    24. 		<< (a + 3 >= b) << endl;
    25.  
    26. }

    • 第十二节 逻辑运算

    根据给定的逻辑因子（表达式或值）返回一个新的逻辑因子。
        &&            逻辑与            a&&b            如果a和b都为真，则结果为真，否则为假。
        ||            逻辑或            a||b            如果a和b有一个为真，则结果为真，二者都为假时，结果为假。
        ！            逻辑非            ！a                如果a为假，则！a为真；如果a为真，则！a为假。

        注意：
        1、逻辑运算符的两边可以是数值，也可以是表达式：
        2、用std::cout输出逻辑运算表达式时，逻辑表达式要加括号；
        3、在实际开发中，逻辑运算的多重组合是重点。

    • 第十三节  逗号运算

    把一行语句中的多个表达式连接起来，程序将从左到右执行表达式。
        语法：表达式一，表达式二，表达式n；

        逗号表达式常用于声明多个变量。

        int a,b          // 声明变量a和b
        int a=10,b=20    //声明变量a和b并初始化。

        也可以用于其他语句中，但是，逗号运算符是所有运算符中级别最低的，以下两个表达式的效果是不同的。

        int a, b;
        b = a = a, a * 2;       //此时输出的a和b的结果都是2.
        b = (a = 2, a * 2);     // 此时输出的结果a=2，b=4.

    1. #include
    2.  
    3. using namespace std;
    4.  
    5. int main()
    6. {
    7. 	int a(10), b(20);
    8. 	cout << "a = " << a << endl;
    9. 	cout << "b = " << b << endl;
    10. 	cout << "\n";
    11.  
    12. 	int c = 30, d = 40;
    13. 	cout << "c = " << c << endl;      cout << "d = " << d << endl;
    14. 	cout << "\n";
    15.  
    16. 	int e, f;
    17. 	e = 50, f = 60;
    18. 	cout << "e = " << e << endl;
    19. 	cout << "f = " << f << endl;
    20. 	cout << "\n";
    21.  
    22. 	return 0;
    23. }

    • 第十四节   运算的优先级

    一个表达式可以包含多个运算符，运算符的优先级决定了表达式各部分的执行顺序。
        例如，按照运算规则，*的优先级比+高，所以b*c将先执行：a+b*c
        如果想让a+b先执行，则必须使用括号：（a+b）*c
        如果一个表达式中的两个操作数具有相同的优先级，那么他们的结合律决定了他们
        的执行顺序（从左到右或从右到左）。例如算术运算的组合方式是从左到右，赋值
        运算符则是从右到左。如下：
        a/b%c        从左到右            （a/b）%c
        a=b=c       从右到左          a=（b=c）

        下表是全部运算符的优先级和结合律：

    1. #include
    2.  
    3. using namespace std;
    4.  
    5. int main()
    6. {
    7. 	int a = 2, b = 3, c = 1;
    8. 	
    9. 	cout << "a * b / c =" << a << endl;
    10.  
    11. }

    • 第十五节 if语句的基本结构

    if(表达式)
        {
            表达式为真时执行的语句；
        }
        else
        {
            表达式为假时执行的语句；
        }

        注意：
          1、  if(表达式)之间的空格可以不写。
          2、  表达式必须使用括号
          3、 表达式可以是具体的值
          4、表达式一般是关系运算和逻辑运算表达式，也可以是赋值运算或其他的表达式。
          5、不要把if（变量名==值）写成if（变量名=值）
          6、 整个if语句可以没有else分支。
          7、  if或else分支花括号内的代码如果只有一行，花括号可以不写，如果一行也没有，花括号一定要写；如果有多行，花括号一定要写，
          8、  如果不写，除了第一行，其他的代码将不是if语句的一部分。
          9、  if（表达式）和else后面不能加分号，因为分号表示空语句。

    1. #include
    2.  
    3. using namespace std;
    4.  
    5. int main()
    6. {
    7. 	int a = 2, b = 3 ,c=0;
    8. 	cout << "请输入2 + 3 =";
    9. 	cin >> c;
    10. 	if (c == a + b)
    11. 	{
    12. 		cout << "正确" << endl;
    13. 	}
    14. 	else
    15. 	{
    16. 		cout << "错误" << endl;
    17. 	}
    18. }

    • 第十六节  嵌套使用if语句

    if语句可以嵌套使用，实现多级（层）的条件判断（最多127层）。

        语法：
        if（表达式1）
        {
            if（表达式2）
            {
                //表达式为真时执行的语句。
            }
            else
            {
                表达式2为假时执行的语句。
            }
        }
        else
        {
            //表达式1为假时执行的语句。
        }


        多条件的if语句

        语法：
        if（表达式1）
        {
            //表达式1为真时执行的语句。
        }
        else if（表达式2）
        {
            //表达式2为真时执行的语句。
        }
        else if（表达式3）
        {
            //表达式3为真时执行的语句。
        }
        .......
        else if（表达式n）
        {
            //表达式n为真时执行的语句。
        }
        else
        {
            //全部表达式都不为真时执行的语句。
        }

        注意：
            多条件的if语句本质上是嵌套的if语句。
            最多只能有127个条件分支。
     

    1. #include
    2.  
    3. //写一个判断输入的年份是不是闰年？
    4.  
    5. using namespace std;
    6.  
    7. int main()
    8. {
    9. 	// 1、声明变量
    10. 	int year;
    11. 	// 2、输出提示输入年份的信息
    12. 	cout << "请输入一个年份：";
    13. 	// 3、输入一个年份
    14. 	cin >> year;
    15. 	// 4、判断这个年份是不是能被4整除
    16. 	if(year % 4 == 0)
    17. 	{
    18. 	      // 5、并且不能被100整除
    19. 		if (year % 100 != 0)
    20. 		{
    21. 			cout << year << " 是闰年。" << endl;
    22. 		}
    23. 		else cout << year << "是平年" << endl;
    24. 	}
    25. 	else
    26. 	{
    27. 		if (year % 400 == 0)
    28. 		{
    29. 			//   6、判断是不是能被400整除
    30. 			cout << year << "是闰年。" << endl;
    31. 		}
    32. 		else
    33. 		{
    34. 			cout << year << "是平年" << endl;
    35. 		}
    36. 	}
    37.  
    38.  
    39. 	
    40.  
    41. 	return 0;
    42. }

    if语句中的逻辑表达式

    采用括号、对齐、空格、换行有助于更清晰的表达复杂的逻辑表达式。

    上面的判断某一年是闰年平年的程序可以修改一下：

    1. #include
    2.  
    3. using namespace std;
    4.  
    5. int main()
    6. {
    7. 	int year = 0;
    8. 	cout << "请输入一个年份：";
    9. 	cin >> year;
    10. 	if ((year % 4 == 0) &&
    11. 		(year % 100 != 0))
    12. 	{
    13. 		cout << year << "年 是闰年" << endl;
    14. 	}
    15. 	else
    16. 	{
    17. 		if (year % 400 == 0)
    18. 		{
    19. 			cout << year << "年 是闰年" << endl;
    20. 		}
    21. 		else
    22. 		{
    23. 			cout << year << "年 是平年" << endl;
    24. 		}
    25. 	}
    26. 	return 0;
    27. }
    28.

    第十七节 三目运算

    三目运算也叫条件运算或三元运算，可以实现简单if语句的功能，但是书写更简洁。

        语法：  表达式1 ？ 表达式2 : 表达式3
        先计算表达式1的值，如果为真，整个表达式的结果为表达式2的值，如果为假，整个表达式的结果为表达式3的值。

        三目运算表达式可以嵌套使用，但是，过于复杂的三目运算表达式不方便理解。
        比如判断year是不是闰年，是则返回1，不是返回0.
        int year;
        year = (year % 100 == 0) ? (year % 400 == 0 ? 1 : 0) : (year % 4 == 0 ? 1 : 0)
        上面的三目嵌套运算虽然能够计算出是不是闰年，但是过于复杂，不建议这么写。

    1. #include
    2.  
    3. using namespace std;
    4.  
    5. int main()
    6. {
    7. 	// 两个数比较大小，取较大值？
    8. 	int a1 = 6, b1 = 9, c1 = 0;
    9. 	c1 = a1 > b1 ? a1 : b1;
    10. 	cout << "c1=" << c1 << endl;
    11.  
    12. 	//三个数比较大小，去较大值？
    13. 	int a = 2, b(3), c{ 5 }, d = 0;
    14. 	d = (a > b ? a : b) > c ? (a > b ? a : b) : c;
    15. 	cout << "d=" << d << endl;
    16. }

    第十八节  switch语句

    switch也是一种选择结构的语句，可以代替简单的多条件的if语句。
        语法：
        switch（表达式）
        {
            case 值1：
                语句1；
                break；
            case 值2：
                语句2：
                break；
            ......
            case 值n：
                语句n；
                break；
            default：
                上述条件都不满足时执行的语句；
        }

        注意：
            1、case后面必须是整数和字符，或者是结果为整数和数字的表达式，但不能使用变量。
            2、default不是必须的，当没有default时，如果全部的case匹配失败，那么就什么都不执行。
            3、每个分支不要漏写break。

    1. #include
    2.  
    3. using namespace std;
    4.  
    5. int main()
    6. {
    7. 	int a = 0;
    8. 	cout << "请输入一个1位的小于6的数字：";
    9. 	cin >> a;
    10. 	switch (a)
    11. 	{
    12. 		case 1:
    13. 			cout << "您输入的是数字1" << endl;
    14. 			break;
    15. 		case 2:
    16. 			cout << "您输入的是数字2" << endl;
    17. 			break;
    18. 		case 3:
    19. 			cout<< "您输入的是数字3" << endl;
    20. 			break;
    21.  
    22. 		case 4: cout << "您输入的是数字4" << endl; break;
    23.  
    24. 		case 5: cout << "您输入的是数字5" << endl; break;
    25.  
    26. 		default: cout << "你输入的数字不对，重新输入。";
    27. 	}
    28.  
    29. 	return 0;
    30. }

    第十九节   while循环

    语法：
        while（表达式）
        {
            语句块
        }
        先计算表达式的值，如果值为真就执行语句块，执行完语句块后，
        回到循环首部再次计算表达式的值，如果为真又执行一次语句块......，
        这个过程会一直重复，直到表达式的值为假时不再执行语句块。

        注意：
            如果表达式的值为真，那么将进入死循环，所以在循环中应该有改变表达式的值的方法。
            如果循环体中的语句块只有一行代码，大括号可以不书写。
            

    1. #include
    2. #define SHUZI 50     // 猜数字游戏，要猜的数字。
    3. using namespace std;
    4.  
    5. int main()
    6. {
    7. 	int num=1;
    8. 	while (num)
    9. 	{
    10. 		cout << "请输入你心中猜想的数字：";
    11. 		cin >> num;
    12. 		if (num > SHUZI)
    13. 			cout << "你猜大了！\n";
    14. 		else if (num < SHUZI)
    15. 			cout << "你猜小了！\n";
    16. 		else
    17. 		{
    18. 			cout << "恭喜你，猜对了！\n";
    19. 			break;
    20. 		}
    21.  
    22. 	}
    23. }

    • 第二十节  循环的跳转

    break和continue两个关键字用于控制循环体中代码的执行流程。
        break跳出（终止）当前循环语句。
        continue回到当前循环语句的首部。

    1. #include
    2.  
    3. // 输出100以内的偶数
    4.  
    5. using namespace std;
    6.  
    7. int main()
    8. {
    9. 	int a = 0;
    10. 	while(a<1000)      //a的取值范围是1-1000
    11. 	{
    12. 		a++;                    // a=a+1
    13. 		if (a == 100) break;         //如果a等于100就结束循环
    14. 		if (a % 2 == 1) continue;    //如果a对2取余的结果等于1，也就是奇数就结束本次循环。
    15. 		cout << "a=" << a << endl;   // 输出a的值（最后只有小于100并且是偶数才能到这行代码了。）
    16. 		
    17. 	}
    18. 	return 0;
    19. }

    • 第二十一节  for循环语句

    语法：
        for（语句一；表达式；语句二）
        {
            语句块；
        }

        1、循环开始的时候，先执行语句一，在整个循环过程中语句一只会被执行一次。
        2、判断表达式的值，如果为真，就执行一次循环体中的语句块。
        3、执行完语句块后，执行一次语句二。
        4、重复第2步和第3步，直到表达式的值不为真就结束for循环。

        注意：
        不要纠结for循环与while循环的区别，他们本质上没有区别。
        for循环一般需要一个相当于计数器的变量，在语句一中对它进行初始化，在语句二中进行计数操作。
        在for循环的语句一中，可以声明计数器变量。
        在for循环中，语句一、表达式和 语句二 都可以为空，for（；；）等同于 while（True）。
        continue和break两个关键字也可以用在for循环体中。

    1. #include
    2.  
    3. // 输出100以内的偶数
    4.  
    5. using namespace std;
    6.  
    7. int main()
    8. {
    9. 	for (int a = 0; a < 1000; a++)
    10. 	{
    11. 		if (a == 100) break;        //如果a等于100就结束循环
    12. 		if (a % 2 == 1) continue;   //如果a对2取余的结果等于1，也就是奇数就结束本次循环。
    13. 		cout << "a=" << a << endl;  // 输出a的值（最后只有小于100并且是偶数才能到这行代码了。）
    14. 	}
    15. }

    • 第二十二节 do...while循环语句

    语法：
            do
            {
                语句块；
            }while（表达式）；

            功能与while语句类似，不同的是：

            1、进入循环时，先执行一次语句块，再计算表达式的值。
            2、循环的首部写在循环的尾部，（表达式）后面还有一个分号。

    1. #include
    2.  
    3. using namespace std;
    4.  
    5. int main()
    6. {
    7. 	int a = 0;
    8. 	do 
    9. 	{
    10. 		cout << "********************  菜单  ***********************" << endl;
    11. 		cout << "******************* 0:退出  ***********************" << endl;
    12. 		cout << "******************* 1:开始  ***********************\n" << endl;
    13. 		cout << "请输入你的选择："; cin >> a;
    14. 		switch (a)
    15. 		{
    16. 			case 0: break;
    17. 			case 1: cout << "开始程序！" << endl;
    18. 			default: 
    19. 				cout << "输入错误！重新输入！"<
    20. 		}
    21. 	} while (a);
    22. 	return 0;
    23. }

    • 第二十三节 goto 语句

    goto 语句也称为无条件转移语句。
        goto 的语法：goto语句标号；
        语句标号的语法：语句标号：

        如果在程序中使用了goto，程序的流程将跳转到语句标号的位置，并执行后面的代码。

        其中语句标号是按标识符规定书写的符号，放在某一语句行的前面，可以独占一行，标号后面加半角冒号。

        语句标号用于标识语句的位置，与goto语句配合使用。

        在实际开发中，goto语句容易造成程序流程的混乱，不方便理解，调试也更麻烦，不建议使用。

    1. #include
    2.  
    3. using namespace std;
    4.  
    5. int main()
    6. {
    7. 	int a = 0;
    8. aaa:
    9. 	cout << "a=" << a << endl;
    10. 	a++;
    11.  
    12. 	if (a == 10)
    13. 		goto bbb;
    14. 	goto aaa;
    15. 	
    16. bbb:
    17. 	cout << "程序到此结束！" << endl;
    18.  
    19. 	return 0;
    20. }

    • 第二十四节  函数的声明和定义

    在复杂的程序中，如果全部的代码都写在main函数中，main函数体将非常庞大臃肿。
        把任务分工到其他的函数中，main函数只负责程序的核心流程，具体的任务由其他函数完成。
        这种思想就是模块化编程。

        声明和定义函数的语法：
        返回值的数据类型  函数名（参数1的数据类型 参数1， 参数2的数据类型 参数2，......）
        {
            实现函数的功能代码。
            return 返回值；
        }

        注意：

            1、函数的声明和定义可以书写在一起，也可以分开，如果书写在一起，一般放在main函数的上面，
            如果分开，一般在main函数的上面声明，在main函数的下面定义。

            2、如果函数的声明和定义分开书写，函数的声明后面一定要有分号，函数的定义后面一定不能写分号。

            3、在同一个程序中，函数只需要声明和定义一次，也可以多次声明，但只能定义一次。

            4、函数的声明必须和函数的定义一致（返回值的数据类型、函数名、参数列表）。

            5、return语句返回值的数据类型必须与函数的声明一致。

            6、如果函数的重点是实现功能，不关心返回值，返回值的数据类型填void，return语句后面就空着。

            7、函数可以没有任何参数。

    1. #include
    2.  
    3. using namespace std;
    4.  
    5. int max(int a, int b);  // 函数的声明
    6.  
    7. int main()
    8. {
    9. 	cout << max(7, 8) << endl;  //函数的调用
    10. 	return 0;
    11. }
    12.  
    13.  
    14.  
    15. int max(int a, int b)  // 函数的定义
    16. {
    17. 	return a > b ? a : b;   // 如果a大于b就返回a，否则就返回b
    18. }

    • 第二十五节  函数的调用

    语法：函数名（参数1，参数2）

        注意：

            1、函数先声明，后调用。

            2、调用函数的时候，参数列表必须与函数的声明一致。

            3、函数中可以调用main函数外的其他函数。

            4、调用函数的代码可以独占一条语句，也可以用于表达式（赋值运算、算术运算、关系运算、函数的参数）。

            5、如果函数用于表达式中，返回值的数据类型要匹配（否则可能会被隐式转换或编译错误）。

            6、如果函数有返回值，可以不关心它，忽略它。

    1. #include
    2.  
    3. using namespace std;
    4.  
    5. void printml();// 声明九九乘法表函数
    6.  
    7. int main()
    8. {
    9. 	printml(); //调用九九乘法表函数
    10. 	return 0;
    11. }
    12.  
    13. // 定义九九乘法表函数
    14. void printml()
    15. {
    16. 	int i = 0, j(0);
    17. 	for (i = 1; i < 10; i++)
    18. 	{
    19. 		for (j = 1; j < 10; j++)
    20. 		{
    21. 			if(j<=i) cout << j << "*" << i << "=" << i * j << "    ";
    22. 		}
    23. 		cout << endl;
    24. 	}
    25. }

    • 变量的作用域

    作用域是指程序中变量存在（或生效）的区域，超过该区域变量就不能被访问。
        变量分全局变量和局部变量两种，全局变量在整个程序中都可以访问，局部变量只能在函数或语句块的内部才能访问。
        C++中定义变量的场景主要有五种：
            1、在全部函数外部定义的是全局变量。
            2、在头文件中定义的是全局变量。
            3、在函数和语句块内部定义的是局部变量。
            4、函数的参数是该函数的局部变量。
            5、函数内部用static修饰的是静态局部变量。
                
                1：全局变量： 再整个程序声明周期内都是有效的，在定义位置之后的任意函数中都能访问。
                             全局变量在主程序退出时有系统收回内存空间。

                2：局部变量： 在函数或语句块内部的语句使用，在函数或语句块外部是不可用的。
                             局部变量在函数返回或语句块结束时有系统回收内存空间。

                3：静态局部变量：用static修饰的静态局部变量只执行初始化一次，直到程序运行结束以后才释放。
                                其作用域为局部，当定义它的函数或语句块结束时，其作用域随之结束。
                                当程序想要使用全局变量的时候应该先考虑使用static（考虑到数据安全性）。
                4：注意事项：
                            全局变量和静态变量自动初始化为0.
                            局部变量不会自动初始化，其值是不确定的，程序中应该有初始化局部变量的代码，否则编译可能会报错（不同的编译器不一样）。
                            局部变量和全局变量名称可以相同，在某函数或语句块内部，如果局部变量名与全局变量名相同，就会屏蔽全局变量而使用局部变量，
                            可以在变量名前加两个冒号（：：）。
                            for循环初始化语句中定义的变量是局部变量。

    1. #include
    2.  
    3. using namespace std;
    4.  
    5. int a = 10;
    6. void fun1()
    7. {
    8. 	a++;
    9. 	cout << "全局变量a=" << a << endl;
    10. }
    11.  
    12. void fun2()
    13. {
    14. 	a++;
    15. 	cout << "全局变量a=" << a << endl;
    16. 	
    17. 	{  //大括号内部是一个语句块，超出范围变量就会被消除。不会影响其他地方的a的值
    18. 		a = 50;
    19. 		cout << "全局变量a=" << ::a << endl;   // 这句变量a中加了两个冒号，说明使用的是全局变量，不是a=50
    20. 	}
    21. }
    22.  
    23.  
    24. int main()
    25. {
    26. 	static int b = 10;
    27. 	a++;
    28. 	cout << "全局变量a=" << a << endl;
    29.  
    30. 	{	//大括号内部是一个语句块，超出范围变量就会被消除，main函数中的语句块除外。
    31. 		a = 20;   // 这个变量值的更改是影响整个生命周期的。
    32. 		cout << "全局变量a=" << a << endl;
    33. 	}
    34.  
    35. 	fun1();
    36. 	fun2();
    37. }

    •  第二十六节     函数参数的传递


            调用函数的时候，调用者把数值付给了函数的参数。
            实参：调用者程序中书写的函数名括号中的参数，可以是常量，变量和表达式。
            形参：函数的参数列表。
            在函数中，修改形参的值，不会影响实参。

    1. #include
    2.  
    3. using namespace std;
    4.  
    5. void bb(int a)
    6. {
    7. 	a = 100;
    8. 	cout << "子函数中a=" << a << endl;
    9. }
    10.  
    11. int main()
    12. {
    13. 	int a = 10;
    14. 	bb(a);  //调用子函数bb，并传入a的值，这里只是赋值了一个a传入子函数。
    15. 	cout << "主函数中a=" << a << endl;
    16. }

    • 第二十七节   函数分文件编写

    头文件（*.h）：需要包含的头文件，指定命名空间，声明全局变量，函数的声明，数据结构和类的声明等。

        源文件（*.cpp）：函数的定义、类的定义。

        主程序：main函数，程序的核心流程，需要用#include“头文件名”把头文件包含进来。

        编译：
            Windows是集成开发环境，不需要写编译指令。
            在linux系统下，把全部的源文件一起编译，如：q++ -o demo demo.cpp public.cpp

    这是main函数

    1. #include"bijiao.h"
    2. #include"dayin.h"
    3.  
    4. int main()
    5. {
    6. 	cout << max(5, 9) << endl;
    7. 	cout << min(7, 8) << endl;
    8. 	print(8, "去公园玩！");
    9. }

    1. #pragma once
    2. #include
    3.  
    4. using namespace std;
    5.  
    6. int max(int x, int y);
    7. int min(int x, int y);

    1. #include"bijiao.h"
    2.  
    3. int max(int x, int y)
    4. {
    5. 	return x > y ? x : y;
    6. }
    7.  
    8. int min(int x, int y)
    9. {
    10. 	return x < y ? x : y;
    11. }

    1. #pragma once
    2. #include
    3.  
    4. using namespace std;
    5.  
    6.  
    7. void print(int x, string str);

    • 第二十八节   递归函数

    在函数中调用自己的情况，叫做递归。
        递归中要有终止递归的条件产生，慢慢的逼近终止条件。

        递归的由来：
                    函数的嵌套调用函数 进入函数的过程是递去  函数返回来的过程是归来  

    1. #include
    2.  
    3. using namespace std;
    4.  
    5. int fun(int x)
    6. {
    7. 	if (x == 0) return 0;
    8. 	return x + fun(x - 1);
    9. }
    10.  
    11. int main()
    12. {
    13. 	// 用递归的方式求1+到100的和：
    14. 	cout << "递归方式：fun(100)=" << fun(100) << endl;
    15.  
    16.  
    17. 	// 用循环的方式求1+到100的和：
    18. 	int sum = 0;
    19. 	for (int i = 1; i <= 100; i++)
    20. 	{
    21. 		sum += i;
    22. 	}
    23. 	cout << "循环方式：sum=" << sum << endl;
    24. 	
    25. }

    • 第三十九课   sizeof关键字

    sizeof运算符是用于求数据类型或变量占用的内存空间。
        用于数据类型：  sizeof（数据类型）
        用于变量：      sizeof（变量名） 或 sizeof 变量名

        注意：
            在32位和64位操作系统中，同一种数据类型占用的内存空间可能不一样。
            字符串（string）不是c++的基本数据类型，用sizeof求它占用内存的大小没有意义。

    1. #include
    2.  
    3. using namespace std;
    4.  
    5. int main()
    6. {
    7. 	cout << "sizeof(char)=" << sizeof(char) << endl;
    8. 	cout << "sizeof(int)=" << sizeof(int) << endl;
    9. 	cout << "sizeof(float)=" << sizeof(float) << endl;
    10. 	cout << "sizeof(double)=" << sizeof(double) << endl;
    11. 	cout << "sizeof(bool)=" << sizeof(bool) << endl << endl << endl;
    12.  
    13. 	cout << "下面是sizeof变量名" << "\n\n\n";
    14.  
    15. 	char a1; cout << "sizeof(char （a1）)=" << sizeof(a1) << endl;
    16. 	int b1; cout << "sizeof(int （b1）)=" << sizeof(b1) << endl;
    17. 	float c1; cout << "sizeof(float （c1）)=" << sizeof(c1) << endl;
    18. 	double d1; cout << "sizeof(double （d1）)=" << sizeof(d1) << endl;
    19. 	bool e1; cout << "sizeof(bool （e1）)=" << sizeof(e1) << "\n\n\n";
    20.  
    21. 	cout << "下面是sizeof变量名(不带括号的)/n" << endl<
    22.  
    23. 	char a2; cout << "sizeof(char a2)=" << sizeof a2 << endl;
    24. 	int b2; cout << "sizeof(int b2)=" << sizeof b2 << endl;
    25. 	float c2; cout << "sizeof(float c2)=" << sizeof c2 << endl;
    26. 	double d2; cout << "sizeof(double d2)=" << sizeof d2 << endl;
    27. 	bool e2; cout << "sizeof(bool e2)=" << sizeof e2 << endl;
    28. }

    • 第四十节  整型的基本概念

    C++用int关键字来声明整型变量（int是interger[ˈɪntɪdʒə(r)]的简写）
            在声明整型变量的时候，可以在int关键字之前加signed，unsigned，short和long四种修饰符。
            signed：有符号的，可以表示正数和负数。
            unsigned：无符号的，只能表示正数，例如身高体重等。
            short：短的，取值范围小，占用内存少。
            long：长的，取值范围大，占用内存多。

            注意：
            整数的取值范围与计算机操作系统和C++语言编译器有关，没有一个固定的数值，我们可以根据它占用的内存大小来推断它的的取值范围。
            a、一个字节有8个位，表示数据的取值范围是0-2进制的8个1,1111 1111  即：0-255.
            b、如果占用的内存是2个字节，无符号的取值范围就是16个1到0,1111 1111 1111 1111 十六进制的4个F，65535-0.
            c、如果占用的内存是4个字节，无符号的取值范围就是32个1到0，1111 1111 1111 1111 1111 1111 1111 1111十六进制的8个F，4,294,967,295-0.
            d、如果占用的是内存8个字节，无符号的取值范围就是64个1到0。
            e、如果有符号，取值范围减半，因为符号占一个位。
            f、计算机用最高位1位来表示符号（0-整数，1-负数），unsigned修饰过的正数不需要符号位，在表达正整数的时候比signed修饰的正整数取值大一倍。
            
            给整数变量赋值不能超过他的取值范围，否则能产生不可预测的后果。
            在实际开发中，为了防止超出取值范围，应该保存足够的空间。

    1. #include
    2.  
    3. using namespace std;
    4. int main()
    5. {
    6. 	unsigned short a;   // unsigned short占用2个字节
    7. 	cout << "unsigned short a=" << sizeof(a) << endl;
    8. 	// 1111 1111 1111 1111这就是short的最大值四个F,16个1,最大值就是16个位都是1,65535。
    9. 	a = 65535;
    10. 	cout << "a 赋值 65535 后 a=" << a << endl;  // 这个结果正常就是65535
    11. 	a = 65536;
    12. 	cout << "a 赋值 65536 后 a=" << a << endl;  // 这个结果是0，因为65535存储时16位已经都是1了，再加上1，就要进位了，也就是第17位为1，其他都为0，截取16位，所以结果为0.
    13. 	a = 65537;
    14. 	cout << "a 赋值 65537 后 a=" << a << endl; // 这个结果是1，因为65535存储时16位已经都是1了，再加上2，就要进位了，也就是第17位为1，第一位为1，截取16位，所以结果为1.
    15.  
    16. }

    • 第四十一节  整数的书写


        整数默认是十进制，一个表示十进制的数字不需要特殊的格式。

    二进制：
        二进制由0和1两个数字组成，书写时必须以0b或0B（不区分大小写）开头。

    八进制：
        八进制由0~7八个数字组成，书写时必须以0开头（注意是数字0，不是字母o）

    十六进制：
        十六进制有数字0~9、字母A~F或a~f（不区分大小写）组成，书写时必须以0x或0X（不区分大小写）开头。

        注意：
            在C++中，不要在十进制前面加0，会被编译器当成八进制。
            还有，不要随便删掉被人程序中整数前面的0，它不是多余的。

    1. #include
    2.  
    3. using namespace std;
    4.  
    5. int main()
    6. {
    7. 	int a;
    8. 	//赋值十进制
    9. 	a = 100;
    10. 	cout << "a=" << a << endl;
    11. 	//赋值二进制
    12. 	a = 0B0110101;
    13. 	cout << "a=" << a << endl;
    14. 	// 赋值八进制
    15. 	a = 0123;
    16. 	cout << "a=" << a << endl;
    17. 	a = -0123;
    18. 	cout << "a=" << a << endl;
    19. 	//赋值十六进制
    20. 	a = 0Xfd;
    21. 	cout << "a=" << a << endl;
    22. 	a = -0Xde;
    23. 	cout << "a=" << a << endl;
    24. }

    • 第四十二节   C++11的 long long类型

    在VS中，long是4字节，32位。
        在linux中，long是8字节，64位。
        C++11标准增了long long 类型的整数，至少64位，且至少与long一样长。

        在VS中，long long是8字节， 64位。
        在linux中， long和long long 类型都是8字节，64位。

    1. #include
    2. using namespace std;
    3. int main()
    4. {
    5. 	cout << "sizeof(long)=" << sizeof(long) << endl;
    6. 	cout << "sizeof(long long)=" << sizeof(long long) << endl;
    7. }

    • 第四十三节   浮点数（实数型）

    C++浮点型分三种：float（单精度）、double（双精度）、long double（扩展精度）。
        三者的区别是有效数字的范围不同。
        float               4字节                  7位有效数字
        double              8字节                  15~16位有效数字
        long double         不少于double           不低于double
        
        注意：
            在VS和Linux中，long double 占用的内存空间分别是8和16字节。
            有效数字包括了小数点前面和后面的数字。
            C++缺省显示6位有效数字，如果要显示更多的有效数字，可以用printf（）函数。
            浮点数的存储方法和整数不一样，比较复杂，如无必要，不用研究。（百度“为什么浮点数的小数位很多”，“为什么浮点数不精确”）
            在实际开发中，用整数代替浮点数，整数的运算更快，精度更高。

    1. #include
    2.  
    3. using namespace std;
    4.  
    5. int main()
    6. {
    7. 	cout << "sizeof(float)" << sizeof(float) << endl;
    8. 	cout << "sizeof(double)=" << sizeof(double) << endl;
    9. 	cout << "sizeof(long double)=" << sizeof(long double) << endl<
    10.  
    11. 	float a = 12345678.4f;
    12. 	printf("float a=%lf", a); printf("\n");
    13. 	double b = 1234567891234567.4;
    14. 	printf("double b = %lf\n", b);
    15. 	long double c= 1234567891234567.4;
    16. 	printf("long double c = %lf\n", c);
    17. 	
    18. }

    • 第四十四节  字符型的基本概念

    字符型（char）占用的内存空间是1个字节，书写用单引号包含。
        在内存中，不存放字符本身，而是存放与它对应的编码，即ASCII码。
        ASCII是现今最通用的单字节编码方案，包含了33个控制字符（具有特殊含义无法显示的字符）和95个可显示字符。

        字符的本质
        1、字符的本质是整数，取值范围是0~127.
        2、在书写的时候可以用单引号包含，也可以用整数。
        3、如果书写的时候用单引号包含，程序执行的时候，将把符号解释为对应的整数。
        4、显示的时候，把整数解释为对应的符号，也可直接显示整数。
        5、可以与整数进行任何运算，运算的时候，书写方式可以用符号，也可以用整数。
        6、C++为什么没有提供1字节的整型？

    第 0～32 号及第 127 号（共 34 个）是控制字符或通讯专用字符，如控制符 LF（换行）、CR（回车）、FF（换页）、DEL（删除）、BEL（振铃）等，通讯专用字符 SOH（文头）、EOT（文尾）、ACK（确认）等。

    第 33～126 号（共94个）是字符，其中第 48～57 号为 0～9 十个阿拉伯数字，65～90 号为 26 个大写英文字母，97～122 号为 26 个小写英文字母，其余为一些标点符号、运算符号等。

    1. #include
    2.  
    3. using namespace std;
    4.  
    5. int main()
    6. {
    7. 	char a = 65;
    8. 	cout << "a+3=" << char(a + 3)<< endl;
    9. 	//虽然字符型存储的是数字，显示的确是字符，如果想要显示数字就用int强制类型转换就显示数字了。
    10. 	cout << "a=" << int(a) << endl;
    11. 	
    12. }

    • 第四十五节  转义字符

    在C++程序中，使用转义字符的原因有两个：
        1、控制字符没有符号，无法书写，只能用其他的符号代替。
        2、某些符号已被C++征用，语义突出，只能用其他的符号代替。

    1. #include
    2. using namespace std;
    3. int main()
    4. {
    5. 	//水平制表符的使用
    6. 	cout << "1:\t小雪" << endl;
    7. 	cout << "100:\t小花" << endl;
    8. 	cout << "10000:\t小\"红" << endl;  //加入1个双引号，会自动和字符串两边的双引号匹配，为了只是输出双引号就加一个转义字符\.
    9. 	
    10. }

    • 第四十六节   C++11的原始字面量

    原始字面量（值）可以直接表示字符串的实际含义，不需要转义和连接。
               语法：R"(字符串的内容)"
                          R"XXX(字符串的内容)XXX"

    1. #include
    2.  
    3. using namespace std;
    4.  
    5. int main()
    6. {
    7. 	string path1 = "D:\\c语言集成开发环境\\项目文件\\C++demo";   //这里的斜杠就要用两个，不然就会出错
    8. 	cout << "path1=" << path1 << endl;
    9.  
    10. 	string path2 = R"(D:\\c语言集成开发环境\\项目文件\\C++demo)";   //前面加R，然后用括号包裹起来，也可以
    11. 	cout << "path1=" << path2 << endl;
    12.  
    13. 	string path3 = R"abcd(D:\\c语言集成开发环境\\项目文件\\C++demo)abcd";   //前面加R，然后用括号包裹起来，括号两端可以有英文字符，但是不打印
    14. 	cout << "path1=" << path3 << endl;
    15.  
    16. 	// 如果字符串的内容太长，可以换行来书写。
    17. 	string path4 = R"abcd(D:\\          
    18. 					c语言集成开发环境\\
    19. 					项目文件\\C++demo
    20. 						  )abcd";   
    21. 	cout << "path1=" << path4 << endl;

    • 第四十七节   字符串型

    C++风格字符串：string 变量名="字符串的内容"；
        C 风格字符串：char 变量名[]="字符串的内容"；

        C风格字符串的本质是字符数组，C++风格字符串的本质是类，它封装了C风格字符串

        C++风格字符串的常用操作：
            赋值  ：  变量名="字符串的内容";
            拼接  ：  变量名=变量名+"字符串内容1"+"字符串内容2"+......+"字符串内容n";
            字符串内容可以分成多行书写，+可以不写。
     

    1. #include
    2.  
    3. using namespace std;
    4.  
    5. int main()
    6. {
    7. 	string name = "大海！";
    8. 	string neirong1 = "你太美了！";
    9. 	string neirong2 = "我好喜欢你！";
    10.  
    11. 	name = name + neirong1 + neirong2;
    12.  
    13. 	cout << name << endl;
    14.  
    15. 	name = name + "你好大啊！"                    //这里就开始省略加号的使用了。
    16. 		"大到你妈都不认识你啦！" "是不是啊！";
    17. 	cout << name << endl;
    18.  
    19. 	return 0;
    20. }

    •  第四十八节   布尔型

    在C和C++中，关系运算和逻辑运算的结果有两种：真和假。
        C语言用0表示假，非0表示真。
        为了提高代码的可读性，C++新增了bool类型，占用1字节的内存，用true表示真，false表示假。
        bool类型本质1字节的整数（字符），取值只有1和0.
        在程序中，书写的时候可以用true和false，编译器把他们解释为1和0.
        用cin输入和cout输出的时候，仍是1和0，不会解释为true和false。

    1. #include
    2.  
    3. using namespace std;
    4. int main()
    5. {
    6. 	bool a = true;
    7. 	bool b = 0;
    8. 	cout << "a+b=" << a + b << endl;
    9. 	cin >> a;
    10. 	cout << "sizeof(a)=" << sizeof(a) << endl;
    11. 	cout << "a+b=" << a + b << endl;
    12. 	return 0;
    13. }

    • 第四十九节  数据类型的转换

    计算机进行运算时，要求各种操作数的类型具有相同的大小和存储方式。
        在实际开发中，不同类型的数据进行混合运算是基本需求。
        自动类型转换：某些类型的转换编译器可以隐式的进行，不需程序员干预。
        强制类型转换：有些类型的转换需要程序员显式指定。
        1、自动类型转换
            不同数据类型的差别在于取值范围和精度，数据的取值范围越大，精度越高。
            整型从低到高：
                char -> short ->int -> long -> long long
            浮点型从低到高：
                float -> double -> long double

            自动类型转换的规则如下：
                如果一个表达式中出现不同类型操作数的混合运算，较低类型将自动向较高类型转换。
                当表达式中含有浮点型操作数时，所有操作数都将转换为浮点型。
                赋值运算的右值类型与左值类型不一致时，将右值类型提升/降低为左值类型。
                赋值运算右值超出了左值类型的表示范围，把该右值截断后赋给左值，所得的结果可能毫无意义。

        2、强制类型转换
            为了让程序员设计更灵活，转换的目的更清晰，C++提供了强制类型转换的方法，也称之为显式转换。

            强制类型转换的语法：（目标类型）表达式

                注意：
                    如果使用强制转换，表示程序员已有明确的目的。
                    如果转换的行为不合理，后果由程序员承担。
                    如果才用了强制类型转换，编译的告警信息将不再出现。
                    类型转换运算符的优先级比较高，如果没把握就加括号。

    1. #include
    2.  
    3. using namespace std;
    4. int main()
    5. {
    6. 	char a = 2;
    7. 	int b = 2147483648; //1000 0000 0000 0000 0000 0000 0000 0000 = 2147483648
    8. 	long int c = 0B1000000000000000000000000000000000000000000000000000000000000000;  // 1000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 = 2147483648
    9. 	cout << "a+b+c=" << a + b + c << endl;
    10.  
    11. 	cout << "8/5=" << 8 / 5 << endl;
    12. 	cout << "8/5=" << ((float)8) / 5 << endl;
    13. 	cout << "a+254=" << a + 255 << endl;  // 结果没有发生截断，证明a被隐式提升为int型了。
    14. 	
    15. 	return 0;
    16. }

    第 五十节  数据类型的别名

    创建数据类型的别名有两个目的：
            为名称复杂的类型创建别名，方便书写和记忆。
            创建与平台无关的数据类型，提高程序的兼容性。

        语法：
            typedef 数据类型名 别名;

        在VS中，short是两个字节，int是4个字节，long也是4个字节，long long 是八个字节。
            typedef short           int16_t;    //16位整数。
            typedef int             int32_t;    //32位整数。
            typedef long long       int64_t;    //64位整数。

        在Linux中，short是两个字节，int是四个字节，long也是八个字节，long long也是八个字节。
            typedef short           int16_t;    //16位整数。
            typedef int             int32_t;    //32位整数。
            typedef long long       int64_t;    //64位整数。

        在程序源代码中，只使用别名int16_t 、 int32_t、 int64_t 不使用原名。

    1. #include
    2.  
    3. using namespace std;
    4. int main()
    5. {
    6. 	typedef unsigned int uint;
    7. 	typedef unsigned long ulong;
    8. 	typedef unsigned long long ullong;
    9.  
    10. 	uint a = 256;
    11. 	ulong b = 123456789;
    12. 	ullong c = 9876543210987654;
    13.  
    14. 	cout<<"sizeof(a)=" << sizeof(a) << "a=" << a << endl;
    15. 	cout << "sizeof(b)=" << sizeof(b) << "b=" << b << endl;
    16. 	cout << "sizeof(c)=" << sizeof(c) << "c=" << c << endl;
    17.  
    18. 	return 0;
    19. }

  • 相关阅读:
    2.10 XGBoost模型数学层面的理解(下篇)
    java专项练习(复制数组元素)
    解决OpenCV在Cmake时，因网络问题无法下载部分所需文件
    Visual Subst – 突破常规，让虚拟驱动器 SUBST 无处不挂！
    在Java中，/ 是除法运算符
    从开发到测试再到发布，全方位解析项目上线的完美路程！
    Shell 和 Shell 脚本 （Shell Script）
    云原生之旅 - 14）遵循 GitOps 实践的好工具 ArgoCD
    JavaWeb基础学习Servlet进阶
    前端-文件上传核心思想
  • 原文地址：https://blog.csdn.net/xingyuncao520025/article/details/132661406