//强制类型转换,否则执行语句2

#include<stdio.h>void main(){    int a;    printf("input integer number:");    scanf("%d",&a);    switch    {    case 1:printf("Mondayn");    case 2:printf("Tuesdayn");    case 3:printf("Wednesdayn");    case 4:printf("Thursdayn");    case 5:printf("Fridayn");    case 6:printf("Saturdayn");    case 7:printf("Sundayn");    default:printf("errorn");    }}

条件语句,if语句

if语句

  if语句的3种形式如下:

  第1种形式:

    if(表达式) 语句

  其语义是:如果表达式的值为真,则执行其后的语句,否则不执行该语句。

  第2种形式:

    if(表达式) 

      语句1

    else

      语句2

  其语义是:如果表达式的值为真,则执行语句1,否则执行语句2。

  第3种形式:

    if(表达式1) 

      语句1

    else if(表达式2) 

      语句2

    else if(表达式3) 

      语句3

      ...

    else if(表达式m) 

      语句m

    else

      语句n

  其语义是:依次判断表达式的值,当出现某个值为真时,则执行其对应的语句,然后跳到整个if语句之外继续执行程序。如果所有的表达式均为假,则执行语句n,然后继续执行后续程序。

 

  注意事项:

    (1)3种形式的if语句中在if后面都有”表达式”,一般为逻辑表达式或关系表达式。在执行if语句时先对表达式求解,若表达式的值为0,则按"假"处理;若表达式的值为非0,则按"真"处理,执行指定的语句。

    (2)else子句不能作为语句单独使用,它必须是if语句的一部分,与if配对使用。

    (3)if与else后面可以包含一个或多个内嵌的操作语句,当为多个操作语句时要用”{}”将几个语句括起来成为一个复合语句。

    (4)if语句可以嵌套使用即在if语句中又包含一个或多个if语句,在使用时应注意else总是与它上面的最近的未配对的if配对。

 

  else子句的配对

    在使用if语句的嵌套时,如果使用了else子句,则else子句会采用就近原则,与其最近的if语句进行配对。如果想要将else子句与其他的if语句配对,则需要使用当前else子句与if语句之间的内容用大括号括起来,这样程序会将大括号中的内容作为复合语句处理,就实现了else子句与if语句的配对。

 

#include "stdafx.h"
#include <iostream>

using namespace std;

int _tmain(int argc, _TCHAR* argv[])
{
    int a, b, c, t;

    printf("请输入3个数:n");

    scanf_s("%d%d%d",&a,&b,&c);

    if (a < b)
    {
        t = a;
        a = b;
        b = t;
    }
    if (a < c)
    {
        t = a;
        a = c;
        c = t;
    }
    if (b < c)
    {
        t = b;
        b = c;
        c = t;
    }


    printf("排序如下:n");
    printf("%d,%d,%dn",a,b,c);

    system("Pause");

    return 0;
}

 

逻辑运算符

  &&逻辑与,a&&b,若a,b为真,则a&&b为真。

  ||逻辑或,a||b,若a,b之一为真,则a||b为真。

  !逻辑非,!a,若为真,则!a为假。

  三者的优先次序是:!->&&->||,即"!"为三者中最高的。

 

“==”和”=”之间的区别

  “==”为关系运算符,结合方向是”自左至右”;”=”是赋值运算符,结合方向是”自右至左”。

 

#include "stdafx.h"
#include <iostream>

using namespace std;

int _tmain(int argc, _TCHAR* argv[])
{
    int year;

    printf("请输入年份:n");
    scanf_s("%d",&year);

    if ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0))
        printf("%d年是闰年n",year);
    else
        printf("%d不年是闰年n", year);

    system("Pause");

    return 0;
}

 

#include "stdafx.h"
#include <iostream>

using namespace std;

int Weight(int iArray[], int iNum)
{
    int iRet;
    int iVar = iNum / 3;
    int jVar,mVar,nVar,kVar;
    jVar = mVar = nVar = kVar = 0;

    for (int i = 0; i < iVar; i++)
    {
        jVar += iArray[i];
        mVar += iArray[i + iVar];
        nVar += iArray[i + iVar * 2];
    }

    int* pArray = new int[iVar];

    if (jVar>mVar)
    {
        kVar = 0;
    }
    else if (jVar < mVar)
    {
        kVar = 1;
    }
    else if (jVar == mVar)
    {
        kVar = 2;
    }

    if (iVar == 1)
    {
        iRet = iVar*kVar;
    }
    else
    {
        for (int j = 0; j < iVar; j++)
        {
            pArray[j] = iArray[j + iVar*kVar];
        }

        iRet = Weight(pArray, iVar) + iVar*kVar;
    }

    delete[] pArray;

    return iRet;
}

int _tmain(int argc, _TCHAR* argv[])
{
    int Ball[] = {2,1,1,1,1,1,1,1,1};
    int iWeightBall = Weight(Ball, 9);

    cout << "比较重的小球号码:" << endl;
    cout << iWeightBall << endl;

    system("Pause");

    return 0;
}

 

break语句

  break语句是程序控制跳转语句,可以跳出语句块,常用于switch语句和循环语句中。当程序达到某一条件时,使用break语句进行跳转,跳出当前语句的执行。

 

#include "stdafx.h"
#include <iostream>

using namespace std;

int _tmain(int argc, _TCHAR* argv[])
{
    int bccd = 98;
    printf("单价是多少?n");
    int Price;

    while (1)
    {
        scanf_s("%d", &Price);
        if (Price > bccd)
        {
            printf("你猜的价格高了!n");
        }
        else if (Price < bccd)
        {
            printf("你猜的价格低了!n");
        }
        else
        {
            printf("回答正确!n");
            break;
        }
    }

    system("Pause");

    return 0;
}

 

switch语句

  switch语句能够测试一组有序类型(整型、字符型、枚举型、布尔类型等)的数据,发现匹配的常量时,将执行与该常量关联的语句。switch语句的语法如下:

    switch(表达式)

    {

    case 常量1:

      语句;

      break;

    case 常量2:

      语句;

      break;

    ......

    case 常量n:

      语句;

      break;

    default:

      语句;

    }

    其中,表达式必须是有序类型,不能是实数或字符串类型。表达式逐一与case语句部分的常量匹配,如果发现有常量与表达式相匹配,则执行当前case部分的语句,直到遇到break语句为止,或者到达switch语句的末尾(没有遇到break语句)。当表达式没有发现与之匹配的常量时,将执行default部分的代码。default语句是可选的,如果代码中没有提供default语句,并且没有常量与表达式匹配,那么switch语句将不执行任何动作。

 

必威,  case语句使用技巧

    在switch语句中,如果多个case常量需要进行相同的处理,那么可以将多个case语句组织在一起,中间不加break语句,使多个case语句都可以执行同一个语句块。

#include "stdafx.h"
#include <iostream>

using namespace std;

int _tmain(int argc, _TCHAR* argv[])
{
    printf("请输入消费金额:n");

    float dMoney;
    scanf_s("%f",&dMoney);
    int iMoney = dMoney;
    switch (iMoney / 500)
    {
    case 0:
        printf("你的消费没有折扣,金额是:%0.2fn",dMoney);
        break;
    case 1:
        printf("你的消费享受9折,金额是:%0.2f,优惠后的金额是:%0.2fn",dMoney,dMoney*0.9);
        break;
    case 2:case 3:
        printf("你的消费享受8折,金额是:%0.2f,优惠后的金额是:%0.2fn", dMoney, dMoney*0.8);
        break;
    case 4:case 5:
        printf("你的消费享受8折,金额是:%0.2f,优惠后的金额是:%0.2fn", dMoney, dMoney*0.7);
        break;
    case 6:case 7:
        printf("你的消费享受8折,金额是:%0.2f,优惠后的金额是:%0.2fn", dMoney, dMoney*0.6);
        break;
    default:
        printf("你的消费享受8折,金额是:%0.2f,优惠后的金额是:%0.2fn", dMoney, dMoney*0.5);
        break;
    }

    system("Pause");

    return 0;
}

 

枚举类型

  枚举类型能够将一组枚举常量与一个枚举类型名称关联。枚举类型就像是一个常量的集中营,在这个集中营中,常量被冠名为枚举常量,如果参数以某一个枚举类型定义参数类型,那么在调用该函数时,就只有该集中营的枚举类型作为参数通过,虽然其他常量的值和枚举常量的值可以相同,但是由于不属于当前枚举类型这个集中营,所以在作为参数调用函数时不能通过。使用关键字enum定义一个枚举类型。

  在定义枚举类型时,可以为各个枚举常量提供一个整数值,如果没有提供整数值,默认第一个常量值为0,第二个常量值为1,依此类推。

 

  为枚举常量赋默认值

    enum RecordsetState {RS_OPEN=3,RS_WAIT,RS_CLOSE=6};

  上面的语句将枚举常量RS_OPEN设置为3,将枚举常量RS_CLOSE设置为6,没有为RS_WAIT提供默认值,RS_WAIT的数值为前一个枚举常量值加1,因此RS_WAIT的数值为4。

 

#include "stdafx.h"
#include <iostream>

using namespace std;

typedef enum NUMBER {ONE,TWO,THREE,FOUR,FIVE,SIX,SEVEN};

int _tmain(int argc, _TCHAR* argv[])
{
    NUMBER num = FIVE;

    switch (num)
    {
    case SEVEN:
        cout << "    *************    " << endl;
    case SIX:
        cout << "     ***********    " << endl;
    case FIVE:
        cout << "      *********        " << endl;
    case FOUR:
        cout << "       *******        " << endl;
    case THREE:
        cout << "        *****        " << endl;
    case TWO:
        cout << "         ***        " << endl;
    case ONE:
        cout << "          *            " << endl;
    }

    system("Pause");

    return 0;
}

 

if 语句 if 语句的 3 种形式如下: 第 1 种形式: if( 表达式 ) 语句 其语义是:如果表达式的值为真,则执行其后的语句,...

在程序中,程序运行的流程控制决定程序是如何执行的,是我们必须掌握的,主要有三大流程控制语句。

华氏度和摄氏度之间的转换

//C=(F-32)*5/9
//问题:从键盘输入一个华氏温度,将其转换为对应的摄氏温度,并打印出来.

#include <stdio.h>
int main (int argc, char  *argv[])
{
// 1. 变量定义
 //数据类型 变量名 = 初始值;
int f = 0;
double c = 0.0;
// 2. 从键盘读入数据
// scanf ("格式控制字符串",地址列表);
printf ("input f : ");
scanf ("%d",&f);
// 3. 进行相应的运算得到结果
//C语言支持算数,关系,逻辑,赋值,位运算...
c = (f - 32)*5/9;
// 4. 打印输出结果
// printf("格式控制字符串",变量列表);
printf ("%fn",c);

return 0;
}

语句n+1;

注意:在case后的各常量表达式的值不能相同,否则会出现错误。

分支控制

让程序有选择的执行,分支控制有三种:

单分支

if 条件表达式 {    //执行代码块}

双分支

if 条件表达式 {    //执行代码块} else {    //执行代码块}

多分支

if 条件表达式1 {    //执行代码块} else if 条件表达式2 {    //执行代码块} else {    //执行代码块}

注意:

{}是必须有的,就算你只写一行代码;

条件表达式不需要小括号括起来

块内声明的变量的作用域只在该块内

golang支持在if中,直接定义一个变量

if age := 20; age > 18 {    //代码块}

if语句的条件表达式不能是赋值语句

if b = false { //错误    }

if语句的条件表达式的结果必须是bool值

n := 4if n { //错误    }

if 语句

if 语句有三种形式:

  1. 基本形式:if;
  2. if-else形式;
  3. if-else-if形式;
#include <stdio.h>
// 等第成绩对应公式
// [90,100]            A
// [80, 89]            B
// [70, 79]            C
// [60, 69]            D
// [0 , 59]            E
// 问题: 从键盘输入一个学生成绩,打印出其等第成绩
int main (int argc, char *argv[])
{
// 1. 定义一个整型变量,存储学生成绩(百分制)
int score = 0;
// 2. 从键盘输入学生成绩 (合法的范围为[0,100])
printf ("input score : ");
scanf ("%d",&score);
// 3. 分析学生成绩的范围,并打印的等第成绩
if ( score >=90  && score <=100)
{
printf ("score = %dtAn",score);
}
else if (score >= 80 && score <= 89);
{
printf ("Bn");
}
else if (score >= 70 && score <=79);
{
printf ("Cn");
}
else if (score >=60 && score <= 69);
{
printf ("Dn");
}
else if (score >= 0 && score <= 59);
{
printf ("En");
}
else
{
printf ("score errorn")
}
return 0;
}

使用if语句时,应注意以下几点:
1.在三种形式的if语句中,在if关键字之后均为表达式.该表达式可以是:逻辑表达式,关系表达式,赋值表达式等等.
2.在if语句中,条件判断表达式必须用括号括起来,在语句之后必须加分号.
3.在if语句的三种形式中,所有的语句应为单个语句,如果想要满足题哦啊件时执行一组(多个)语句,则必须把这一组语句用{}括起来组成一个复合语句.但要注意的是在}之后不能再加分号.

if(a>b)max=a;

C语言提供了另一种用于多分支选择的switch语句,一般形式为:

顺序控制

程序从上到下逐行的执行,中间没有任何判断和跳转。

开关语句(switch)

switch是一种用于多分支选择的语句,而不是一种循环语句.如下

#include <stdio.h>
int main ()
{
switch (整数类型的值)
{
case 常量1:
break;
case 常量2:
break;
case 常量3:
break;
...
default:
break;
}
return 0;
}

计算表达式的值:并逐个与其后的常量表达式值相比较,当表达式的值与某个常量表达式的值相等时,即执行其后的语句,然后不在进行判断,继续执行后面所有case后的语句.如表达式的值与所有case后的常量表达式均不相同,则执行default后的语句.
在使用switch语句时,应注意以下几点:

  1. 在case后的各常量表达式的值不能相同,否则会出错.
  2. 在case后,允许有多个语句,可以不用{}括起来.
  3. default子句可以省略不用;
  4. 各case和default子句的先后顺序可以变动,而不影响程序执行的结果.

int a;

#include<stdio.h>int main(){    char rank;    printf("请输入分数等级:(A、B、C、D、E)n");    scanf("%c",&rank);    switch        {        case'A':printf("An");break;        case'B':printf("Bn");break;        case'C':printf("Cn");break;        case'D':printf("Dn");break;        case'E':printf("En");break;        default:printf("error!n");break;    }

goto

  • Go语言的goto语句可以无条件地转移到程序中指定的行。
  • goto语句通常与条件语句配合使用。可以用来实现条件转移,跳出循环体等功能。
  • 在Go程序设计中一般不主张使用goto语句,以免造成程序流程的混乱,使理解和调试程序都产生困难。

语法:

goto labellabel: statement

示例:

package mainimport "fmt"func main() {    fmt.Println;    goto label1    fmt.Println;    fmt.Println;    fmt.Println;    label1:    fmt.Println;}//输出结果15

必威 1

类型转换

// 隐式类型转换(自动类型转换):当不同类型的数据进行运算时,会自动将低精度向高精度进行自动转换.

c = (f - 32)*5.0/9;

//强制类型转换:利用数据强制生成指定类型的临时值.
(数据类型)常量或变量;

c = (double)(f - 32)*5/9;

// 练习:将华氏零度到华氏100度及其相对应的摄氏温度打印出来
// 华氏 摄氏
// 1. ,,

#include <stdio.h>
int main (int argc,  char *argv[])
{
// 1. 定义相关变量
int f = 0;
double c = 0.0;
f = 1;
while (f <= 100)
{
// 2. 利用数据(可以是从键盘输入,也可以是通过某种运算生成的)进行运算,从而
//获得需要的数据
c = (f - 32)*5.0/9;
// 3. 打印输出
printf ("%dt%fn",f,c);
f = f + 1;
}
return 0;
}

语句一;

switch {case 常量1 :语句;case 常量2 :语句;case 常量3 :语句;...case 常量n:语句;default :语句;}语义:计算常量表达式的值,并逐个与其后的常量值相比较,当表达式的值与某个常量值相等时,即执行其后语句,然后不再进行判断,继续执行后面所有case后的语句。若表达式的值与所有case后的常量值均不同时,则执行default语句。错例:

目录

if(b)语句:

default子句可以省略不用。

循环控制

Go语言中的循环语句只支持for关键字,不支持while和do-where结构。

关系表达式的值是真和假,用“1”和“0”来表示。

在case后允许有多个语句,可以不用{}括起来。

for

语法:

Go语言的for循环有三种形式,只有其中的一种使用分号。

  • 和C语言的for一样:

    for init; condition; post {}
    
  • 和C的while一样:

    for condition {}
    
  • 和C的for一样:

    for {}
    
    • init:一般为赋值表达式,给控制变量赋初值;

    • condition:关系表达式或逻辑表达式;循环控制条件

    • post:一般为赋值表达式,给控制变量增量或减量。

      for循环的range格式可以对slice、map、数组、字符串等进行迭代循环。格式如下:

      for key, value := range oldMap {    newMap[key] = value}
      

在Go语言中,仅仅可以用一个for不加任何条件的执行循环,如果for循环内部没有break语句,它会一直循环下去

必威 2

Go语言的关键字也可以实现其它编程语言里while的功能,比如定义一个变量a,当a>=20时就跳出循环,否则一直循环下去。

必威 3

细节说明:

如果我们在遍历一个字符串时,字符串中含有中文,那么传统的遍历字符串方式for(i :=0; i<len是错误的,会出现乱码。原因是传统的对字符串的遍历是按照字节来遍历,而一个汉字在utf8编码是对应3个字节。

如何解决?

1.需要将str转成[]rune切片

2.对应for-range遍历方式而言,是按照字符方式遍历的。因此如果字符串中有中文,也是可以的。

break语句:专用于跳出switch语句,break语句只有关键字break,没有参数。

为避免上述输出时出现的情况,C语言提供了一种break语句,专用于跳出switch语句,break语句只有关键字break,没有参数。

  • 顺序控制
  • 分支控制
  • 循环控制

关系运算符的优先级低于算数运算符。

只能针对基本数据类型中的整型类型使用switch,这些类型包括int、char等。对于其他类型,则必须使用if语句。

continue

continue语句用于结束本次循环,继续执行下一次循环。

continue语句出现在多层嵌套的循环语句体中时,可以通过标签知名要跳过的是哪一层循环,这个和前面的break

  • 标签的使用规则一样。

scanf函数:格式输出函数

#include<stdio.h>void main(){    int a;    printf("input integer number:");    scanf("%d",&a);    switch    {    case 1:printf("Mondayn");break;    case 2:printf("Tuesdayn");break;    case 3:printf("Wednesdayn");break;    case 4:printf("Thursdayn");break;    case 5:printf("Fridayn");break;    case 6:printf("Saturdayn");break;    case 7:printf("Sundayn");break;    default:printf("errorn");break;    }}

switch

switch语句用于基于不同条件执行不同动作,每一个case分支都是唯一的,从上到下逐一测试,直到匹配位置。

匹配项后面也不需要再加break

基本语法:

switch 表达式 {    case 表达式1,表达式2, ... :        语句块    case 表达式3,表达式4, ... :        语句块    case 表达式5:        语句块    default:        语句块}

流程图

必威 4

  1. switch的执行流程是,先执行表达式,得到值,然后和case的表达式进行比较,如果相等,就匹配到,然后执行对应的case的语句块,然后退出switch控制,如果一个都匹配不到,则执行default。

  2. default语句不是必须的。

  3. 如果switch的表达式的值没有和任何的case的表达式匹配成功,则执行default的语句块。执行后退出switch的控制。

  4. golang的case后的表达式可以有多个,使用逗号间隔。

  5. golang中的case语句块不需要写break,因为默认会有,即在默认情况下,当程序执行完case语句块后,就直接退出该switch控制结构。

  6. fallthrough:与下面的一个case条件属于逻辑或的关系,相等于给下面的一个case增加了一个逻辑或的条件

    必威 5

  7. case后面的各个表达式的值的数据类型,必须和switch的表达式数据类型一致

    package mainimport "fmt"func main() {    var num1 int32 = 20    var num2 int64 = 20    switch num1 {    case num2:        fmt.Println    case 30:        fmt.Println    }}//运行时报错invalid case num2 in switch on num1 (mismatched types int64 and int32)
    

    但是如果里面是一个数字,则可以的,因为数字本身是不带类型的

    package mainimport "fmt"func main() {    var num1 int32 = 20    switch num1 {    case 20.0:        fmt.Println    case 30:        fmt.Println    }}
    
  8. golang中switch后面的表达式甚至不是必须的

    必威 6

  9. Type switch

    switch语句还可以被用于type-switch来判断某个interface变量中实际存储的变量类型。

    Type Switch语法格式如下:

    switch x. { case type:     statement;    case type:     statement;     //你可以定义任意个数的case    default: /*可选*/     statement;}
    

    示例:

    package mainimport "fmt"func main() {    var x interface{}    switch i := x. { //x.()格式是类型断言    case nil:        fmt.Printf("x 的类型是: %T", i)    case int:        fmt.Printf("x 的类型是: int")    case float64:        fmt.Printf("x的类型是: float64")    case func float64:        fmt.Printf("x的类型是: func    case bool, string:        fmt.Printf("x的类型是: bool或string")    default:        fmt.Printf    }}//以上代码的执行结果为:x 的类型是: <nil>
    
  10. case后是一个表达式(即:常量值、变量、一个有返回值的函数等都可以)

  11. case后面的表达式如果是常量值,则要求不能重复

    package mainimport "fmt"func main() {    var n1 int32 = 5    var n2 int32 = 20    var n3 int32 = 5    switch n1 {        case n2, 10, 5:            fmt.Println        case 5: //这里不允许重复出现数字5,但是如果我们把5替换成变量n3就不会报错            fmt.Println    }}
    
  12. switch后面也可以直接声明/定义一个变量,分号结束,不推荐

    switch grade := 90; {    case grade > 90:    fmt.Println("成绩优秀...")    case grade >= 60 && grade <= 90:    fmt.Println    default:    fmt.Println}
    
  13. switch和if的比较

    如果判断的具体数值不多,而且符合整数、浮点数、字符、字符串这几种类型,建议使用switch语句,简洁高效。

    其他情况:对区间判断和结果为bool类型的判断,使用if,if使用的范围更广

分支程序设计

正例:

break

break语句用于终止某个语句块的执行,用于中断当前for循环或跳出switch语句。break是跳出整个循环。

break语句出现在多层嵌套的语句块中时,可以通过标签指明要终止的是哪一层语句块。

package mainimport "fmt"func main() {    //label1:    for i := 0; i < 4; i++ {        label2:        for j := 0; j < 5; j++ {            if j == 2 {                //break  //break默认会跳出最近的循环                //break label1;                break label2;            }            fmt.Println("j = ", j)        }    }}

default:                   语句n+1;

switch()的参数类型不能为实型 。case标签必须是常量表达式(constantExpression),如42或者"42"。例:

  • 顺序控制
  • 分支控制
    • switch
  • 循环控制
    • for
    • break
    • continue
    • goto

语句n;

各case和default子句的先后顺序可以变动,而不会影响程序执行结果。

getchar 函数(键盘输入函数):从键盘上输入一个字符。

......

关系运算符:在程序中经常要比较两个量的大小关系,以决定程序下一步的工作,比较两个量的运算符称为关系运算符。

{a++;

例如

a>b?a:(c>d?c:d)

scanf("%dn",&a);

else

应理解为

使用条件运算符时,还应注意以下几点:

1)&&与运算

case 5:printf("Fridaayn",a);break;

(2)在if语句中,条件判断表达式必须用括号括起来,在语句之后必须加分号。

这也就是条件表达式嵌套的情形,即其中的表达式又是一个条件表达式。

1)在case后的各常量表达式的值不能相同,否则会出现错误,

其一般形式为getchar();eg

4)default句子可以省略不用。

{

本文由必威发布于必威-编程,转载请注明出处://强制类型转换,否则执行语句2

TAG标签:
Ctrl+D 将本页面保存为书签,全面了解最新资讯,方便快捷。