C++基础（二）

0x05 运算符

算数运算符

运算符	描述	实例
+	把两个操作数相加	A + B 将得到 30
-	从第一个操作数中减去第二个操作数	A - B 将得到 -10
*	把两个操作数相乘	A * B 将得到 200
/	分子除以分母	B / A 将得到 2
%	取模运算符，整除后的余数	B % A 将得到 0
++	自增运算符，整数值增加 1	A++ 将得到 11
--	自减运算符，整数值减少 1	A-- 将得到 9

关系运算符

运算符	描述	实例
==	检查两个操作数的值是否相等，如果相等则条件为真。	(A == B) 不为真。
!=	检查两个操作数的值是否相等，如果不相等则条件为真。	(A != B) 为真。
>	检查左操作数的值是否大于右操作数的值，如果是则条件为真。	(A > B) 不为真。
<	检查左操作数的值是否小于右操作数的值，如果是则条件为真。	(A < B) 为真。
>=	检查左操作数的值是否大于或等于右操作数的值，如果是则条件为真。	(A >= B) 不为真。
<=	检查左操作数的值是否小于或等于右操作数的值，如果是则条件为真。	(A <= B) 为真。

#include <iostream>
using namespace std;

int main()
{
	int a = 1;
	int b = 2;
	int c;
	if ( a==b )
	{
		cout << "a=b" << endl;
	}
	else
	{
		cout << "a!=b" << endl;
	}
	if ( a<b )
	{
		cout << "a<b" << endl;
	}
	else
	{
		cout << "a!<b" << endl;
	}
	return 0;
}

逻辑运算符

运算符	描述	实例
&&	称为逻辑与运算符。如果两个操作数都非零，则条件为真。	(A && B) 为假。
||	称为逻辑或运算符。如果两个操作数中有任意一个非零，则条件为真。	(A || B) 为真。
!	称为逻辑非运算符。用来逆转操作数的逻辑状态。如果条件为真则逻辑非运算符将使其为假。	!(A && B) 为真。

#include <iostream>
using namespace std;

int main()
{
	int a = 1;
	int b = 2;
	int c;
	if ( a&&b )
	{
		cout << "a&&b 真" << endl;
	}
	else
	{
		cout << "a&&b 假" << endl;
	}
	if ( !(a && b))
	{
		cout << "a&&b ! 真 " << endl;
	}
	else
	{
		cout << "a&&b ! 假 " << endl;
	}
	return 0;
}

位运算符

p	q	p & q	p | q	p ^ q
0	0	0	0	0
0	1	0	1	1
1	1	1	1	0
1	0	0	1	1

运算符	描述	实例
&	如果同时存在于两个操作数中，二进制 AND 运算符复制一位到结果中。	(A & B) 将得到 12，即为 0000 1100
|	如果存在于任一操作数中，二进制 OR 运算符复制一位到结果中。	(A | B) 将得到 61，即为 0011 1101
^	如果存在于其中一个操作数中但不同时存在于两个操作数中，二进制异或运算符复制一位到结果中。	(A ^ B) 将得到 49，即为 0011 0001
~	二进制补码运算符是一元运算符，具有"翻转"位效果。	(~A ) 将得到 -61，即为 1100 0011，2 的补码形式，带符号的二进制数。
<<	二进制左移运算符。左操作数的值向左移动右操作数指定的位数。	A << 2 将得到 240，即为 1111 0000
>>	二进制右移运算符。左操作数的值向右移动右操作数指定的位数。	A >> 2 将得到 15，即为 0000 1111

假设如果 A = 60，且 B = 13，现在以二进制格式表示，它们如下所示：

A = 0011 1100
B = 0000 1101

-----------------

A&B = 0000 1100 
A|B = 0011 1101 
A^B = 0011 0001 
~A  = 1100 0011

赋值运算符

运算符	描述	实例
=	简单的赋值运算符，把右边操作数的值赋给左边操作数	C = A + B 将把 A + B 的值赋给 C
+=	加且赋值运算符，把右边操作数加上左边操作数的结果赋值给左边操作数	C += A 相当于 C = C + A
-=	减且赋值运算符，把左边操作数减去右边操作数的结果赋值给左边操作数	C -= A 相当于 C = C - A
*=	乘且赋值运算符，把右边操作数乘以左边操作数的结果赋值给左边操作数	C *= A 相当于 C = C * A
/=	除且赋值运算符，把左边操作数除以右边操作数的结果赋值给左边操作数	C /= A 相当于 C = C / A
%=	求模且赋值运算符，求两个操作数的模赋值给左边操作数	C %= A 相当于 C = C % A
<<=	左移且赋值运算符	C <<= 2 等同于 C = C << 2
>>=	右移且赋值运算符	C >>= 2 等同于 C = C >> 2
&=	按位与且赋值运算符	C &= 2 等同于 C = C & 2
^=	按位异或且赋值运算符	C ^= 2 等同于 C = C ^ 2
|=	按位或且赋值运算符	C |= 2 等同于 C = C | 2

杂项运算符

运算符	描述
sizeof	sizeof 运算符返回变量的大小。例如，sizeof(a) 将返回 4，其中 a 是整数。
Condition ? X : Y	条件运算符。如果 Condition 为真 ? 则值为 X : 否则值为 Y。
,	逗号运算符会顺序执行一系列运算。整个逗号表达式的值是以逗号分隔的列表中的最后一个表达式的值。
.（点）和 ->（箭头）	成员运算符用于引用类、结构和共用体的成员。
Cast	强制转换运算符把一种数据类型转换为另一种数据类型。例如，int(2.2000) 将返回 2。
&	指针运算符 & 返回变量的地址。例如 &a; 将给出变量的实际地址。
*	指针运算符 * 指向一个变量。例如，*var; 将指向变量 var。

优先级

运算符的优先级确定表达式中项的组合。这会影响到一个表达式如何计算。某些运算符比其他运算符有更高的优先级，例如，乘除运算符具有比加减运算符更高的优先级。

例如 x = 7 + 3 * 2，在这里，x 被赋值为 13，而不是 20，因为运算符 * 具有比 + 更高的优先级，所以首先计算乘法 3*2，然后再加上 7。

下表将按运算符优先级从高到低列出各个运算符，具有较高优先级的运算符出现在表格的上面，具有较低优先级的运算符出现在表格的下面。在表达式中，较高优先级的运算符会优先被计算。

类别	运算符	结合性
后缀	() [] -> . ++ - -	从左到右
一元	+ - ! ~ ++ - - (type)* & sizeof	从右到左
乘除	* / %	从左到右
加减	+ -	从左到右
移位	<< >>	从左到右
关系	< <= > >=	从左到右
相等	== !=	从左到右
位与 AND	&	从左到右
位异或 XOR	^	从左到右
位或 OR	|	从左到右
逻辑与 AND	&&	从左到右
逻辑或 OR	||	从左到右
条件	?:	从右到左
赋值	= += -= *= /= %=>>= <<= &= ^= |=	从右到左
逗号	,	从左到右

0x06 循环

循环类型

循环类型	描述
while 循环	当给定条件为真时，重复语句或语句组。它会在执行循环主体之前测试条件。
for 循环	多次执行一个语句序列，简化管理循环变量的代码。
do...while 循环	除了它是在循环主体结尾测试条件外，其他与 while 语句类似。
嵌套循环	您可以在 while、for 或 do..while 循环内使用一个或多个循环。

while

while(condition)
{
   statement(s);
}
在这里，statement(s) 可以是一个单独的语句，也可以是几个语句组成的代码块。condition 可以是任意的表达式，当为任意非零值时都为真。当条件为真时执行循环。当条件为假时，程序流将继续执行紧接着循环的下一条语句。

#include <iostream>
using namespace std;

int main()
{
	int a = 10;
	while (a < 15)
	{
		cout << "a:" << a << endl;
		a++;
	}
	return 0;
}

for

for ( init; condition; increment )
{
   statement(s);
}
init 会首先被执行，且只会执行一次。这一步允许您声明并初始化任何循环控制变量。您也可以不在这里写任何语句，只要有一个分号出现即可。
接下来，会判断 condition。如果为真，则执行循环主体。如果为假，则不执行循环主体，且控制流会跳转到紧接着 for 循环的下一条语句。
在执行完 for 循环主体后，控制流会跳回上面的 increment 语句。该语句允许您更新循环控制变量。该语句可以留空，只要在条件后有一个分号出现即可。
条件再次被判断。如果为真，则执行循环，这个过程会不断重复（循环主体，然后增加步值，再然后重新判断条件）。在条件变为假时，for 循环终止。

#include <iostream>
using namespace std;

int main()
{
	for (int a=10;a<15;a++)
	{
		cout << "a:" << a << endl;
	}
	return 0;
}

do while

do...while 循环是在循环的尾部检查它的条件。do...while 循环与 while 循环类似，但是 do...while 循环会确保至少执行一次循环

do
{
   statement(s);

}while( condition );

条件表达式出现在循环的尾部，所以循环中的 statement(s) 会在条件被测试之前至少执行一次。

如果条件为真，控制流会跳转回上面的 do，然后重新执行循环中的 statement(s)。这个过程会不断重复，直到给定条件变为假为止。

#include <iostream>
using namespace std;

int main()
{
	int a = 10;

	do
	{
		cout << "a:" << a << endl;
		a++;
	} while (a<15); 
	return 0;
}

嵌套循环

for

for ( init; condition; increment )
{
   for ( init; condition; increment )
   {
      statement(s);
   }
   statement(s); // 可以放置更多的语句
}

while

while(condition)
{
   while(condition)
   {
      statement(s);
   }
   statement(s); // 可以放置更多的语句
}

do while

do
{
   statement(s); // 可以放置更多的语句
   do
   {
      statement(s);
   }while( condition );

}while( condition );

例子

#include <iostream>
using namespace std;

int main()
{
	int i, j;
	for (i = 2; i < 100; i++) {
		for (j = 2; j <= (i / j); j++)
		if (!(i % j)) 
			break; // 如果找到，则不是质数
		if (j > (i / j)) 
			cout << i << " 是质数
";
	}
	return 0;
}


#include <iostream>
using namespace std;

int main()
{
	int i, j;
	for (i = 1; i < 10; i++) {

		for (j = 1; j < 10; j++) {
			int qiuji;
			qiuji = i * j;
			cout << i << "*" << j << "="  << qiuji ;
			cout << endl;
		}

	}
	return 0;
}

循环控制

控制语句	描述
break 语句	终止 loop 或 switch 语句，程序流将继续执行紧接着 loop 或 switch 的下一条语句。
continue 语句	引起循环跳过主体的剩余部分，立即重新开始测试条件。
goto 语句	将控制转移到被标记的语句。但是不建议在程序中使用 goto 语句。

break

当 break 语句出现在一个循环内时，循环会立即终止，且程序流将继续执行紧接着循环的下一条语句。

可用于终止 switch 语句中的一个 case。

如果使用的是嵌套循环（即一个循环内嵌套另一个循环），break 语句会停止执行最内层的循环，然后开始执行该块之后的下一行代码。

#include <iostream>
using namespace std;

int main()
{
	int a = 10;
	do
	{
		cout << "a:" << a << endl;
		a++;
		if (a > 15)
		{
			break;
		}
	} while (a<25);
	return 0;
}

contine

 continue 语句有点像 break 语句。但它不是强迫终止，continue 会跳过当前循环中的代码，强迫开始下一次循环。

对于 for 循环，continue 语句会导致执行条件测试和循环增量部分。对于 while 和 do...while 循环，continue 语句会导致程序控制回到条件测试上。

#include <iostream>
using namespace std;

int main()
{  
    int a = 10;
    do
    {
        if (a == 15)
        {
            a = a + 1;
            continue;
        }
        cout << "a：" << a << endl;
        a = a + 1;
    } while (a < 20);
    return 0;
}

contine

goto 语句允许把控制无条件转移到同一函数内的被标记的语句。

注意：在任何编程语言中，都不建议使用 goto 语句。因为它使得程序的控制流难以跟踪，使程序难以理解和难以修改。任何使用 goto 语句的程序可以改写成不需要使用 goto 语句的写法。

goto label;
..
.
label: statement;

#include <iostream>
using namespace std;
 
int main ()
{
   // 局部变量声明
   int a = 10;

   // do 循环执行
   LOOP:do
   {
       if( a == 15)
       {
          // 跳过迭代
          a = a + 1;
          goto LOOP;
       }
       cout << "a 的值：" << a << endl;
       a = a + 1;
   }while( a < 20 );
 
   return 0;
}

无限循环

//如果条件永远不为假，则循环将变成无限循环。for 循环在传统意义上可用于实现无限循环。由于构成循环的三个表达式中任何一个都不是必需的，您可以将某些条件表达式留空来构成一个无限循环。
#include <iostream>
using namespace std;
 
int main ()
{

   for( ; ; )
   {
      printf("This loop will run forever.
");
   }

   return 0;
}

//当条件表达式不存在时，它被假设为真。您也可以设置一个初始值和增量表达式，但是一般情况下，C++ 程序员偏向于使用 for(;;) 结构来表示一个无限循环。

0x07 判断

if

#include <iostream>
using namespace std;

int main()
{
	int a = 10;
	do
	{
		cout << "a:" << a << endl;
		a++;
		if (a > 15)
		{
			break;
		}
	} while (a<25);
	return 0;
}

if else

#include <iostream>
using namespace std;

int main()
{  
    int a = 10;
    if (a < 20) {
        cout << "a<20" << endl;
    }
    else
    {
        cout << "a>20" << endl;
    }
    return 0;
}

嵌套if

#include <iostream>
using namespace std;

int main()
{  
    int a = 80;
    if (a > 60) {
        if ( a == 100) {
            cout << "a is best" << endl;          
        }
        else
        {
            cout << "a can be  best" << endl;
        }
    }
    else
    {
        cout << "a is lower " << endl;
    }
    return 0;
}

switch

//基本语法
switch(expression){
    case constant-expression  :
       statement(s);
       break; // 可选的
    case constant-expression  :
       statement(s);
       break; // 可选的
  
    // 您可以有任意数量的 case 语句
    default : // 可选的
       statement(s);
}

/*
switch 语句必须遵循下面的规则：
switch 语句中的 expression 必须是一个整型或枚举类型，或者是一个 class 类型，其中 class 有一个单一的转换函数将其转换为整型或枚举类型。

在一个 switch 中可以有任意数量的 case 语句。每个 case 后跟一个要比较的值和一个冒号。
case 的 constant-expression 必须与 switch 中的变量具有相同的数据类型，且必须是一个常量或字面量。


当被测试的变量等于 case 中的常量时，case 后跟的语句将被执行，直到遇到 break 语句为止。
当遇到 break 语句时，switch 终止，控制流将跳转到 switch 语句后的下一行。

不是每一个 case 都需要包含 break。如果 case 语句不包含 break，控制流将会 继续 后续的 case，直到遇到 break 为止。

一个 switch 语句可以有一个可选的 default case，出现在 switch 的结尾。default case 可用于在上面所有 case 都不为真时执行一个任务。default case 中的 break 语句不是必需的。
*/


#include <iostream>
using namespace std;

int main()
{  
    char socre = 'B';
    switch (socre) {
    case 'A':
           cout << "a is best" << endl;
           break;
    case 'B':
           cout << "a can be  best" << endl;
           break;
    }
    return 0;
}

嵌套switch

#include <iostream>
using namespace std;
 
int main ()
{
   // 局部变量声明
   int a = 100;
   int b = 200;
 
   switch(a) {
      case 100: 
         cout << "这是外部 switch 的一部分" << endl;
         switch(b) {
            case 200:
               cout << "这是内部 switch 的一部分" << endl;
         }
   }
   cout << "a 的准确值是 " << a << endl;
   cout << "b 的准确值是 " << b << endl;
 
   return 0;
}

0x08 函数

简介

函数是一组一起执行一个任务的语句，每个c++都有主函数main()，所有简单程序都可以定义其他额外的函数

函数声明告诉编译器函数的名称、返回值、参数，函数定义提供了函数的实际主体

常见形式
return_type function_name( parameter list )//函数声明
{
   body of the function
}

返回类型：一个函数可以返回一个值。return_type 是函数返回的值的数据类型。有些函数执行所需的操作而不返回值，在这种情况下，return_type 是关键字 void。
函数名称：这是函数的实际名称。函数名和参数列表一起构成了函数签名。
参数：参数就像是占位符。当函数被调用时，您向参数传递一个值，这个值被称为实际参数。参数列表包括函数参数的类型、顺序、数量。参数是可选的，也就是说，函数可能不包含参数。
函数主体：函数主体包含一组定义函数执行任务的语句。
    
如max函数：
int max(int num1, int num2)//函数声明 声明时候参数名称并不重要，只有类型是必须的，如下也是有效的int max(int, int);
{
    // 局部变量声明
    int result;

    if (num1 > num2)
        result = num1;
    else
        result = num2;

    return result;
}

注意：在一个源文件中定义函数且在另一个文件中调用函数时，函数声明是必需的。在这种情况下，应该在调用函数的文件顶部声明函数

调用函数

创建 C++ 函数时，会定义函数做什么，然后通过调用函数来完成已定义的任务。

当程序调用函数时，程序控制权会转移给被调用的函数。被调用的函数执行已定义的任务，当函数的返回语句被执行时，或到达函数的结束括号时，会把程序控制权交还给主程序。

调用函数时，传递所需参数，如果函数返回一个值，则可以存储返回值。例如：
#include <iostream>
using namespace std;
 
// 函数声明
int max(int num1, int num2);
 
int main ()
{
   // 局部变量声明
   int a = 100;
   int b = 200;
   int ret;
 
   // 调用函数来获取最大值
   ret = max(a, b);
 
   cout << "Max value is : " << ret << endl;
    return 0; }   // 函数返回两个数中较大的那个数
int max(int num1, int num2)  {    // 局部变量声明
    int result;
    if (num1 > num2)
      result = num1;
   else
      result = num2;
 
   return result; 
}

函数参数

如果函数要使用参数，则必须声明接收参数的变量，变量被称为函数的形式参数

形式参数就像函数内的其他局部变量，在进入函数时被创建，退出函数时被销毁

调用函数时有如下函数传递参数的方式
默认C++使用传值调用来传递参数，意味着函数内的代码不能改变用于调用函数的参数

调用类型	描述
传值调用	该方法把参数的实际值复制给函数的形式参数。在这种情况下，修改函数内的形式参数对实际参数没有影响。
指针调用	该方法把参数的地址复制给形式参数。在函数内，该地址用于访问调用中要用到的实际参数。这意味着，修改形式参数会影响实际参数。
引用调用	该方法把参数的引用复制给形式参数。在函数内，该引用用于访问调用中要用到的实际参数。这意味着，修改形式参数会影响实际参数。

参数的默认值

函数内指定一个参数为默认值，当调用时候如果实际值为空则使用默认值，否则使用设置的参数
    
#include <iostream>
using namespace std;

// 函数声明
int qiuhe(int num1, int num2 = 20) {
    int finalresult;
    finalresult = num1 + num2;
    return(finalresult);
    }  
int main()
{
    int num1 = 1;
    int finalhe;
    finalhe = qiuhe(num1);
    cout << "和为:" << finalhe << endl;

    int num2 = 333;
    finalhe = qiuhe(num2, num1);
    cout << "和为:" << finalhe << endl;
    return 0;
}