C语言入门系列之2.数据类型、运算符和表达式

CuterCorley 等级 373 0 0

一、数据类型

C语言常见数据类型如下: C语言入门系列之2.数据类型、运算符和表达式

1.数据类型

  • 基本数据类型 基本数据类型最主要的特点是,其值不可以再分解为其他类型。 也可以说,基本数据类型是自我说明的。
  • 构造数据类型 构造数据类型是根据已定义的一个或多个数据类型用构造的方法来定义的。 也就是说,一个构造类型的值可以分解成若干个“成员”或“元素”。每个“成员”都是一个基本数据类型或一个构造类型。 在C语言中,构造类型有以下几种:
    • 数组
    • 结构体
    • 共用体(联合)类型
  • 指针类型 指针是一种特殊的、且具有重要作用的数据类型,其值用来表示某个变量在内存储器中的地址。 虽然指针变量的取值类似于整型量,但这是两个类型完全不同的量,因此不能混为一谈。
  • 空类型 在调用函数值时,通常应向调用者返回一个函数值,这个返回的函数值是具有一定的数据类型的,应在函数定义及函数说明中给以说明。 例如在上一节例题中给出的max函数定义中,函数头为int max(int a, int b);,其中int类型说明符即表示该函数的返回值为整型量。 但是,也有一类函数,调用后并不需要向调用者返回函数值,这种函数可以定义为“空类型” ,其类型说明符为void。

2.常量和变量

对于基本数据类型量,按其取值是否可改变又分为常量和变量两种。 在程序执行过程中,其值不发生改变的量称为常量,其值可变的量称为变量。 它们可与数据类型结合起来分类,例如,可分为整型常量、整型变量、浮点常量、浮点变量、字符常量、字符变量、枚举常量、枚举变量。 在程序中,常量是可以不经说明而直接引用的,而变量则必项先定义后使用。 整型量包括整型常量、整型变量。

常量和符号变量

在程序执行过程中,其值不发生改变的量称为常量。 符号常量:用标示符代表一个常量。 在C语言中,可以用一个标识符来表示一个常量,称之为符号常量。 符号常量在使用之前必须先定义,其一般形式为:

#define 标识符 常量

其中#define也是一条预处理命令(预处理命令都以#开头),称为宏定义命令,其功能是把该标识符定义为其后的常量值。一经定义,以后在程序中所有出现该标识符的地方均代之以该常量值。

习惯上符号常量的标识符用大写字母变量标识符用小写字母,以示区别。 举例如下:

#include <stdio.h>
#define PRICE 30

void main()
{
    int num, total;
    num = 10;
    total = num * PRICE;
    printf("total=%d", total);
}

打印:

total=300

其中: #define PRICE 30用标识符代表一个变量,称为符号变量; 符号常量与变量不同,它的值在其作用域内不能改变,也不能再被赋值

使用符号常量的好处:

  • 含义清楚;
  • 能做到”一改全改“。

变量

其值可以改变的量称为变量。一个变量应该有一个名字,在内存中占据一定的存储单元。 变量定义必项放在变量使用之前,一般放在函数体的开头部分。 如下:

int k = 3;

要区分变量名和变量值是两个不同的概念,在上例中,k是变量名,3是变量值。

3.整型数据

整型常量的表示方法

整型常量就是整常数。 在C语言中,使用的整常数有八进制、十六进制和十进制三种:

  • 十进制整常数 十进制整常数没有前缀,其数码为0-9。 以下各数是合法的十进制整常数: 237、-568、65535、1627等。
  • 八进制整常数 八进制整常数必须以0开头,即以0作为八进制数的前缀,数码取值为0-7。 八进制数通常是无符号数。 以下各数是合法的八进制数: 015(十进制为13)、0101(十进制为65)、0177777(十进制为65535)。
  • 十六进制整常数 十六进制整常数的前缀为0X或0x,其数码取值为0-9、A-F或a-f。 以下各数是合法的十六进制整常数: 0X2A(十进制为42)、0XA0 (十进制为160)、0xFFFF (十进制为65535)。

在程序中是根据前缀来区分各种进制数的,在书写常数时不要把前缀弄错造成结果不正确。

整型常数的后缀: 在16位字长的机器上,基本整型的长度也为16位,因此表示的数的范围也是有限定的。十进制无符号整常数的范围为0-65535,有符号数为-32768 - +32767,八进制无符号数的表示范围为0 - 0177777,十六进制无符号数的表示范围为0X0 - 0XFFFF或0x0 - 0xFFFF。 如果使用的数超过了上述范围,就必须用长整型数来表示,长整型数是用后缀 L或l 来表示的。

整型变量

变量定义的一般形式为:

类型说明符  变量名标识符, 变量名标识符, ...;

例如:

int a,b,c;      // a,b,c为整型变量
long x,y;       // x,y为长整型变量
unsigned p,q;   // p,q为无符号整型变量

在书写变量定义时,应注意以下几点:

  • 允许在一个类型说明符后,定义多个相同类型的变量,各变量名之间用“,”号间隔,类型说明符与变量名之间至少用一个空格间隔。
  • 最后一个变量名之后必须以“;”号结尾。
  • 变量定义必须放在变量使用之前。 一般放在函数体的开头部分。

整型数据在内存中的存放形式是二进制,在上例中声明k变量,值为3,以二进制存储示意如下: C语言入门系列之2.数据类型、运算符和表达式

补充--内存中的二进制存储: 1字节Byte = 8位bit。 数值是以补码表示的:

  • 正数的补码与原码相同;

  • 负数的补码 将该数的绝对值的二进制形式按位取反再加1。 举例说明--求-10的补码:

    10的原码: 00001010 取反: 11110101 再加1,得到-10的补码: 11110110

    可以得到,最高位是符号位,1表示负数,0表示整数。

整型变量的分类:

  • 基本型 类型说明符为int,在内存中占4个字节。
  • 短整型 类型说明符为short intshort,在内存中占2个字节。
  • 长整型 类型说明符为long intlong,在内存中占4个字节。
  • 无符号型 类型说明符为unsigned

注意: 这里占多少个字节跟具体的系统和编译器规定有关。

在本机查看不同类型所占位数测试:

#include <stdio.h>

void main()
{
    printf("%d\n", sizeof(int));
    printf("%d\n", sizeof(short));
    printf("%d\n", sizeof(long));
    printf("%d\n", sizeof(unsigned));
}

打印:

4
2
4
4

整型变量信息如下: 类型说明符|数的范围|字节数 ---------|--------|----- int|-2^31^ - (2^31^-1)|4 unsigned int|0 - (2^32^-1)|4 short int|-2^15^ - (2^15^-1)|2 unsigned short int|0 - (2^16^-1)|2 long int|-2^31^ - (2^31^-1)|4 unsigned long|0 - (2^32^-1)|4

整型变量的定义和使用举例如下:

#include <stdio.h>

void main()
{
    int a, b, c, d;
    unsigned u;
    a = 5;
    b = -15;
    u = 12;
    c = a + u;
    d = b + u;
    printf("a+u=%d, b+u=%d\n", c, d);
}

打印:

a+u=17, b+u=-3

在编译运行时a、b、c、d与u的数据类型不一样,会自动将无符号型转化为默认类型有符号型再进行计算。

整型数据的溢出举例如下:

#include <stdio.h>

void main()
{
    short int a, b;
    a = 32767;
    b = a + 1;
    printf("%d, %d", a, b);
}

打印:

32767, -32768

显然,出现了负数-32768。 解释:在本机编译环境中,short int是2个字节16位,2^16^=65536,65536÷2=32768,即short int有符号型的范围是 -32768-32767,而程序中b的值为32768,超出范围即溢出,其二进制为1000000000000000,此时最高位为1表示负数,所以显示了-32768。

再举一个例子,如下:

#include <stdio.h>

void main()
{
    long x, y;
    int a, b, c, d;
    x = 5;
    y = 6;
    a = 7;
    b = 8;
    c = x + a;
    d = y + b;
    printf("c=x+a=%d, d=y+b=%d", c, d);
}

打印:

c=x+a=12, d=y+b=14

从程序中可以看到: x、y是长整型变量,a、b是基本整型变量,它们之间允许进行运算,运算结果为长整型。但c,d被定义为基本整型,此最后结果为基本整型。 本例说明,不同类型的量可以参与运算并相互赋值,其中的类型转换是由编译系统自动完成的。

4.实型数据

Ⅰ.实型常量的表示方法

实型也称为浮点型,实型常量也称为实数或者浮点数。 在C语言中,实数只采用十进制。 它有二种形式:十进制小数形式和指数形式:

  • 十进制小数形式 由数码0-9和小数点组成,必须有小数点。 例如0.0、25.0、5.789、0.13、5.0、300.、-267.8230等均为合法的实数。 标准C允许浮点数使用后缀,后缀为 f或F 即表示该数为浮点数,如 356f 和 356. 是等价的。

  • 指数形式 由十进制数、阶码标志“e”或“E”和阶码(只能为整数,可以带符号)组成。 其一般形式为:

      aEn(a为十进制数,n为十进制整数)

    例如:

    2.1E5 (等于2.1105) 3.7E-2 (等于3.710-2) 0.5E7 (等于0.5107) -2.8E-2 (等于-2.810-2)

    以下不是合法的实数:

    345 (无小数点) E7 (阶码标志E之前无数字) -5 (无阶码标志) 53.-E3 (负号位置不对) 2.7E (无阶码)

Ⅱ.实型变量

实型数据在内存中的存放形式

实型数据一般占4个字节(32位)内存空间,按指数形式存储。 浮点数的二进制存储方式如下: C语言入门系列之2.数据类型、运算符和表达式 举例3.14159在内存中的存放形式如下: 符号|小数部分|指数部分 ---|---|--- +|.314159|1

  • 小数部分占的位(bit)数愈多,数的有效数字愈多,精度愈高;
  • 指数部分占的位数愈多,则能表示的数值范围愈大。

实型变量的分类

  • 单精度(float型)
  • 双精度(double型)
  • 长双精度(long double型)

在Turbo C中单精度型占4个字节(32位)内存空间,其数值范围为3.4E-38-3.4E+38,只能提供七位有效数字;双精度型占8个字节(64位)内存空间,其数值范围为1.7E-308~1.7E+308,可提供16位有效数字。

类型说明符 比特数(字节数) 有效数字 数值范围
float 32(4) 6-7 -2^128^ - 2^128^
double 64(8) 15-16 -2^1024^ - 2^1024^
long double 128(16) 18-19 -2^16384^ - 2^16384^

实型数据的舍入误差

测试如下:

#include <stdio.h>

int main()
{
    float a, b;
    a = 123456.789e5;
    b = a + 20;
    printf("%f\n", a);
    printf("%f\n", b);
    return 0; 
}

打印:

12345678848.000000
12345678848.000000

显然,a的值已经不准确,整数部分后3位产生误差,同时b在a的基础上加20(两位数,在后边的3位误差之内)也会产生误差。

计算以下表达式的值:

(1)1.0 / 3 * 3等于多少? (2)3 / 2呢? (3)1 / 3 * 3呢?

通过程序计算:

#include <stdio.h>

int main()
{
    printf("%f\n", 1.0 / 3 * 3);
    printf("%f\n", 3 / 2);
    printf("%f\n", 1 / 3 * 3);
    return 0; 
}

打印:

1.000000
0.000000
0.000000

5.字符型数据

字符型数据包括字符常量和字符变量。

字符常量

字符常量是用单引号括起来的一个字符。 例如:'a'、'b'、'='、'+'、'?'等都是合法字符常量。

在C语言中,字符常量有以下特点:

  • 字符常量只能用单引号括起来,不能用双引号或其它括号。
  • 字符常量只能是单个字符,不能是字符串。
  • 字符可以是字符集中任意字符,但数字被定义为字符型之后就不能参与数值运算。 如'5'和5是不同的,'5'是字符常量,不能参与运算。

字符变量

字符变量用来存储字符常量,即单个字符,类型说明符是char。 字符变量类型定义的格式和书写规则都与整型变量相同,例如:

char a, b;

转义字符

转义字符是一种特殊的字符常量,以反斜线"\"开头,后跟一个或几个字符。 转义字符具有特定的含义,不同于字符原有的意义,故称转义字符。 例如,在之前的练习中printf()函数的格式串中用到的 \n 就是一个转义字符,其意义是回车换行。 转义字符主要用来表示那些用一般字符不便于表示的控制代码。 所有的转义字符及其含义如下: 转义字符|含义|ASCII码值(十进制) ----|-----|----- \a|响铃(BEL)|007 \b|退格(BS) ,将当前位置移到前一列|008 \f|换页(FF),将当前位置移到下页开头|012 \n|换行(LF) ,将当前位置移到下一行开头|010 \r|回车(CR) ,将当前位置移到本行开头|013 \t|水平制表(HT) (跳到下一个TAB位置)|009 \v|垂直制表(VT)|011 \|代表一个反斜线字符'\|092 '|代表一个单引号(撇号)字符|039 "|代表一个双引号字符|034 ? |代表一个问号| 063 \0|空字符(NUL)|000 \ddd|1到3位八进制数所代表的任意字符|三位八进制 \xhh|十六进制所代表的任意字符|十六进制

转义字符的使用:

#include <stdio.h>

int main()
{
    int a, b, c;
    a = 5, b = 6, c = 7;
    printf(" ab c\tde\rf\n");
    printf("hijk\tL\bM\n");
    return 0; 
}

打印:

fab c   de
hijk    M

字符数据在内存中的存储形式及使用方法: 每个字符变量被分配一个字节的内存空间,因此只能存放一个字符。 字符值是以ASCII码的形式存放在变量的内存单元之中的,如x的十进制ASCII码是120,y的十进制ASCII码是121。 对字符变量a、b赋予'x'和'y'值:

a ='x';
b = '7';

实际上是在a、b两个单元内存放120和55的二进制值。

向字符变量赋以整数:

#include <stdio.h>

int main()
{
    char a, b;
    a = 120;
    b = 121;
    printf("%c, %c\n", a, b);
    printf("%d, %d\n", a, b);
    return 0; 
}

显示:

x, y
120, 121

本程序中定义a、b为字符型,但在赋值语句中赋以整型值。 从结果可以看到,a、b值的输出形式取决于printf()函数格式串中的格式符,当格式符为"c"时,对应输出的变量值为字符,当格式符为"d"时,对应输出的变量值为整数。

下面的代码的效果是一样的:

#include <stdio.h>

int main()
{
    char a, b;
    a = 'x';
    b = 'y';
    printf("%c, %c\n", a, b);
    printf("%d, %d\n", a, b);
    return 0; 
}

练习--小写字母转变成大写字母:

#include <stdio.h>

int main()
{
    char a, b;
    a = 'a';
    b = 'b';
    a = a - 32;
    b = b - 32;
    printf("%c, %c\n%d, %d\n", a, b, a, b);

    return 0; 
}

打印:

A, B
65, 66

char a = 33int a = 33的比较:

#include <stdio.h>

int main()
{
    char a;
    int b;
    a = 33;
    b = 33;
    printf("%c, %c\n%d, %d\n", a, b, a, b);

    return 0; 
}

打印:

!, !
33, 33

显然,效果是一样的,char是int的一种特殊情况,char占1个字节,int占4个字节,显然char更节省内存。

字符串常量

字符串常量是由一对双引号括起的字符序列。 例如:"CHINA"、“C program”、"$12.5" 等都是合法的字符串常量。

字符串常量和字符常量是不同的量。它们之间主要有以下区别:

  • 字符常量由单引号括起来,字符串常量由双引号括起来。
  • 字符常量只能是单个字符,占八位,字符串常量则可以含一个或多个字符。
  • 可以把一个字符常量赋值给一个字符变量,但不能把一个字符串常量赋值给一个字符变量。 例如:可以char a = 'a';,但不能char a = "a";
  • 字符常量占一个字节的内存空间,字符串常量占的内存字节数等于字符串中字节数加1,增加的一个字节中存放字符 \0 (ASCII码为0),这是字符串结束的标志。 例如,字符串C program在内存中所占的字节示意如下: C语言入门系列之2.数据类型、运算符和表达式

字符常量'a'和字符串常量"a"虽然都只有一个字符,但在内存中的情况是不同的:

  • 'a'在内存中占一个字节;
  • "a"在内存中占二个字节。

对比如下: C语言入门系列之2.数据类型、运算符和表达式

6.变量赋初值

在程序中常常需要对变量赋初值,以便使用变量。 C语言中有多种方法为变量提供初值,在作变量定义的同时给变量赋以初值的方法称为初始化。 在变量定义中赋初值的一般形式为:

类型说明符 变量1 = 值1, 变量2 = 值2, ……;

例如:

int a=3;
int b, c=5;
float x=3.2, y=3f, z=0.75;
char ch1='K', ch2='P';

7.变量类型转换

变量的数据类型是可以转换的。 转换的方法有两种,一种是自动转换,一种是强制转换。

自动类型转换

自动转换发生在不同数据类型的量混合运算时,由编译系统自动完成。 自动转换遵循以下规则:

  • 若参与运算量的类型不同,则先转换成同一类型,然后进行运算。
  • 转换按数据长度增加的方向进行,以保证精度不降低。如int型和long型运算时,先把int量转成long型后再进行运算,来保证损失较低、精度较高。
  • 所有的浮点运算都是以双精度进行的,即使仅含float单精度量运算的表达式,也要先转换成double型,再作运算。
  • char型和short型参与运算时,必须先转换成int型
  • 在赋值运算中,赋值号两边量的数据类型不同时,赋值号右边量的类型将转换为左边量的类型。如果右边量的数据类型长度大于左边时,将丢失一部分数据,这样会降低精度,丢失的部分按四舍五入向前舍入。

类型自动转换的规则如下: C语言入门系列之2.数据类型、运算符和表达式

举例如下:

#include <stdio.h>

int main()
{
    float PI = 3.14159;
    int s, r = 5;
    s = r * r * PI;
    printf("s=%d\n", s);

    return 0; 
}

打印:

s=78

程序中,PI为实型,s、r为整型。在执行s = r * r * PI;语句时,r和PI都转换成double型计算,结果也为double型。但由于s为整型,故赋值结果仍为整型,舍去了小数部分。 显然,精度出现损失,可以将s声明为double或float型,计算结果就会更准确,如下:

#include <stdio.h>

int main()
{
    float s, PI = 3.14159;
    int r = 5;
    s = r * r * PI;
    printf("s=%f\n", s);

    return 0; 
}

打印:

s=78.539749

显然,此时结果精确度更高。

强制类型转换

强制类型转换是通过类型转换运算符来实现的。 其一般形式为:

(类型说明符)  (表达式)

其功能是把表达式的运算结果强制转换成类型说明符所表示的类型。 例如:

(float) a      // 把a转换为实型
(int)(x+y)     // 把x+y的结果转换为整型

在使用强制转换时应注意以下问题:

  • 类型说明符和表达式都必须加括号(单个变量可以不加括号),如把(int)(x+y)写成(int)x+y则成了把x转换成int型之后再与y相加了。
  • 无论是强制转换或是自动转换,都只是为了本次运算的需要而对变量的数据长度进行的临时性转换,而不改变数据说明时对该变量定义的类型

举例如下:

#include <stdio.h>

int main()
{
    float f = 3.14159;
    printf("(int)f=%d, f=%f\n", (int)f, f);

    return 0; 
}

显示:

(int)f=3, f=3.141590

因此,(int)f的值为3(删去了小数)而f的值不变,仍为3.14159。 本例表明,f虽强制转为int型,但只在运算中起作用,是临时的,而f变量本身的类型并不改变。

二、运算符和表达式

1.基本算术运算符

  • 加法运算符+ 加法运算符为双目运算符,即应有两个量参与加法运算,如a+b、4+8等。具有右结合性

  • 减法运算符- 减法运算符为双目运算符,但“-”也可作负值运算符,此时为单目运算,如-x, -5等具有左结合性

  • 乘法运算符* 双目运算,具有左结合性

  • 除法运算符/ 双目运算,具有左结合性。 参与运算量均为整型时,结果也为整型,舍去小数;如果运算量中有一个是实型,则结果为双精度实型。

  • 取余运算符% 双目运算,当运算符%的操作数(被除数和除数)均为整数时,结果为取余。 例如,16%5的结果为两数相除的余数1。 当运算符%的操作数中有一个或两个浮点数时,会产生语法错误。 例如8%2.5存在语法错误。

    举例如下:

      #include <stdio.h>
    
      int main()
      {
          printf("\n%d, %d\n", 20 / 7, -20 / 7);
          printf("%f, %f\n", 20.0 / 7, -20 / 7.0);
          printf("%d\n", 100 % 3);
    
          return 0; 
      }

    打印:

    
      2, -2
      2.857143, -2.857143
      1
    

2.运算符的优先级和结合性

  • 运算符的优先级 C语言中,运算符的运算优先级共分为15级,1级最高,15级最低。 在表达式中,优先级较高的先于优先级较低的进行运算,而在一个运算量两侧的运算符优先级相同时,则按运算符的结合性所规定的结合方向处理。
  • 运算符的结合性 C语言中各运算符的结合性分为两种,即左结合性(自左至右)和右结合性(自右至左)。 例如算术运算符的结合性是自左至右,即先左后右。如有表达式x-y+z则y应先与“-”号结合,执行x-y运算,然后再执行+z的运算。这种自左至右的结合方向就称为“左结合性”。 而自右至左的结合方向称为“右结合性”。最典型的右结合性运算符是赋值运算符,如x=y=z,由于“=”的右结合性,应先执行y=z再执行x=(y=z)运算。 C语言运算符中有不少为右结合性,应注意区别,以避免理解错误。

C语言中运算符的优先级和结合性如下: C语言入门系列之2.数据类型、运算符和表达式

3.高级运算符

强制类型转换运算符

强制类型转换部分。

自增、自减运算符

自增1、自减1运算符:

  • 自增1运算符记为“++”,其功能是使变量的值自增1;
  • 自减1运算符记为“--”,其功能是使变量值自减1。

自增1,自减1运算符均为单目运算,都具有右结合性。可有以下几种形式:

  • ++i i自增1后再参与其它运算。
  • --i i自减1后再参与其它运算。
  • i++ i参与运算后,i的值再自增1。
  • i-- i参与运算后,i的值再自减1。

自增、自减运算符测试:

#include <stdio.h>

int main()
{
    int i = 8;
    printf("%d\n", ++i);
    printf("%d\n", --i);
    printf("%d\n", i++);
    printf("%d\n", i--);
    printf("%d\n", -i++);
    printf("%d\n", -i--);
    printf("%d\n", i);

    return 0; 
}

打印:

9
8
8
9
-8
-9
8

再如:

#include <stdio.h>

int main()
{
    int i = 5, j = 5, p ,q;
    p = (i++) + (i++) + (i++);
    q = (++j) + (++j) + (++j);
    printf("%d, %d, %d, %d\n", p, q, i, j);
    i = 5, j = 5;
    p = i++ + i++ + i++;
    q = ++j + ++j + ++j;
    printf("%d, %d, %d, %d\n", p, q, i, j);

    return 0; 
}

打印:

18, 22, 8, 8
18, 22, 8, 8

赋值运算符和赋值表达式

简单赋值运算符和表达式: 简单赋值运算符记为“=”,由“= ”连接的式子称为赋值表达式,其一般形式为:

变量 = 表达式

例如:

x = a + b
w = sin(a) + sin(b)
y = i + j

赋值表达式的功能是计算表达式的值再赋予左边的变量,具有右结合性,因此a=b=c=5可理解为 a=(b=(c=5))

如果赋值运算符两边的数据类型不相同,系统将自动进行类型转换,即把赋值号右边的类型换成左边的类型,具体如下:

  • 实型赋予整型,舍去小数部分。
  • 整型赋予实型,数值不变,但将以浮点形式存放,即增加小数部分(小数部分的值为0)。
  • 字符型赋予整型,由于字符型为1个字节,而整型为4个字节,故将字符的ASCII码值放到整型量的低8位中,其余高位为0。
  • 整型赋予字符型,只把低8位赋予字符量。

举例如下:

#include <stdio.h>

int main()
{
    int a, b = 322;
    float x, y = 8.88;
    char c1 = 'k', c2;
    a = y;
    printf("%d\n", a);
    x = b;
    a = c1;
    c2 = b;
    printf("%f, %d, %c", x, a, c2);  

    return 0; 
}

打印:

8
322.000000, 107, B

在赋值符“=”之前加上其它二目运算符可构成复合赋值符。如+=、-=、*=、/=、%=、<<=、>>=、&=、^=和|=等。 用法举例如下:

a+=5      // 等价于a=a+5
x*=y+7    // 等价于x=x*(y+7)
r%=p      // 等价于r=r%p

复合赋值符这种写法,对初学者可能不习惯,但十分有利于编译处理,能提高编译效率并产生质量较高的目标代码。

逗号运算符和逗号表达式

在C语言中逗号“,”也是一种运算符,称为逗号运算符,其功能是把两个表达式连接起来组成一个表达式,称为逗号表达式。 其一般形式为表达式1, 表达式2。 求值过程是分别求两个表达式的值,并以表达式2的值作为整个逗号表达式的值。 如下:

#include <stdio.h>

int main()
{
    int a = 2, b = 4, c = 6, x, y;
    y = (b + c,(x = a + b));    // 逗号运算符
    printf("y=%d, x=%d", y, x);

    return 0; 
}

打印:

y=6, x=6

对于逗号表达式要注意:

  • 逗号表达式一般形式中的表达式1和表达式2也可以是逗号表达式。 例如表达式1,(表达式2,表达式3)形成了嵌套情形,因此可以把逗号表达式扩展为表达式1,表达式2,…表达式n,整个逗号表达式的值等于表达式n的值。
  • 程序中使用逗号表达式,通常是要分别求逗号表达式内各表达式的值,并不一定要求整个逗号表达式的值。 并不是在所有出现逗号的地方都组成逗号表达式,如在变量说明中和函数参数表中逗号只是用作各变量之间的间隔符。

本文原文首发来自博客专栏C语言学习,由本人转发至https://www.helloworld.net/p/Po8HB5tLnCxw,其他平台均属侵权,可点击https://blog.csdn.net/CUFEECR/article/details/105555179查看原文,也可点击https://blog.csdn.net/CUFEECR浏览更多优质原创内容。

收藏
评论区

相关推荐

C++概述
概述 C 是静态,可编译,通用,大小写敏感,格式自由的编程语言,它支持程序化,面向对象的,和泛型编程方式。 C 被看作是中间层语言,因为它同时包含了低级语言和高级语言的特性。 C 是于 1979 年在新泽西的茉莉山丘的贝尔实验室由 Bjarne Stroustrup 开发的,它是 C 语言的加强版,最开始它被称作 “C with Classes”,但是
C++ 基本语法
C 程序可以定义为对象的集合,这些对象通过调用彼此的方法进行交互。现在让我们简要地看一下什么是类、对象,方法、即时变量。 对象 对象具有状态和行为。例如:一只狗的状态 颜色、名称、品种,行为 摇动、叫唤、吃。对象是类的实例。 类 类可以定义为描述对象行为/状态的模板/蓝图。 方法 从基本上说,一个方法表示一种行为。一个类可以包含多个
【C 陷阱与缺陷 学习笔记】(一)词法陷阱
一 内容 0\. 不同于 当程序员本意是作比较运算时,却可能无意中误写成了赋值运算。 1.本意是检查 x 与 y 是否相等: c if(x y) break; 实际上是将 y 的值赋值给了 x ,然后再检查该值是否为 0 。 2.本意是跳过文件中的空白字符: c while(c '' || c '\t' ||
计算机专业,如何轻松学习C/C++编程?
C/C 是比其他语言难些,但差距不大。以往很多人说 C/C 难,那是旧时代的产物。那时操作系统(例如 DOS)还没有如今这么强大的功能,像界面设计和底层设计都要靠应用程序来实现。由于 C 的高效率,高端设计大都用 C 语言和汇编语言来写,程序搞得很复杂,初学者有望尘莫及的感觉。C 的简捷表达法比 Fortran, Cobol, Pascal 和 BASIC
Swift与Objective-C混合编程之Swift与Objective-C API映射
原创文章,欢迎转载。转载请注明:关东升的博客 Swift与ObjectiveC API映射 在混合编程过程中Swift与ObjectiveC调用是双向的,由于不同语言对于相同API的表述是不同的,他们之间是有某种映射规律的,这种API映射规律主要体现在构造函数和方法两个方面。 1、构造函数映射 在Swift与ObjectiveC语言进行混合
统计字符串中字符出现的次数(Python版)
字符串转list python s 'aabbccd' list1 list(s) 方法一: python list1 'a', 'a', 'b', 'c', 'c', 'c', 'c' dict_cnt {} for value in list1: dict_cntvalue dict_cnt.get(value,
c++11 实现单例模式
C11出来后,里面新增加了好多好用的功能 下面的单例就是使用了C11中的标准库中的mutex和unique_prt 进行内存管理的. 此单例模式不用担心内存的释放问题 pragma once include <memory include <mutex template <class T class Singleton { public: ty
C语言_练习题(一)
前言: 看懂理解代码很容易,难的是把所理解的融会贯通,融合到实例中,你会发现事实和理论会有些许差别,编写实例能更好的帮你积累经验。 0x1 编写一个程序,要求提示输入一个ASCII码值(如,66),然后打印输入的字符。 代码: include <stdio.h int main(){ char i; printf("请输入一个ASCI
我的C语言基础
C语言32个关键字auto 声明自动变量short 声明短整型变量或函数int 声明整型变量或函数long 声明长整型变量或函数float 声明浮点型变量或函数double 声明双精度变量或函数char 声明字符型变量或函数struct 声明结构体变量或函数union 声明共用数据类型enum 声明枚举类型typedef 用以给数据类型取别名co
C语言入门系列之1.C语言概述和上机运行简单C程序
一、C语言的发展过程C语言是在70年代初问世的。一九七八年由美国电话电报公司(AT&T)贝尔实验室正式发表了C语言,同时由B.W.Kernighan和D.M.Ritchit合著了著名的《THE C PROGRAMMING LANGUAGE》一书 ,通常简称为《K&R》,也有人称之为 《K&R》标准。但是,在《K&R》中并没有定义一个完整的C语言标
C语言入门系列之2.数据类型、运算符和表达式
一、数据类型C语言常见数据类型如下: 1.数据类型 基本数据类型基本数据类型最主要的特点是,其值不可以再分解为其他类型。也可以说,基本数据类型是自我说明的。 构造数据类型构造数据类型是根据已定义的一个或多个数据类型用构造的方法来定义的。也就是说,一个构造类型的值可以分解成若干个“成员”或“元素”。每个“成员”都是一个基本数据类型或
C语言基础习题50例(一)1-5
虎为百兽尊,罔敢触其怒。惟有父子情,一步一回顾。 习题1 有 1 、 2 、 3 、 4 个数字,能组成多少个互不相同且无重复数字的三位数?都是多少?实现思路:显然,这个题目需要用到循环,并且是循环嵌套,先列出所有可能的组合,再去掉重复的组合即可。代码如下:cinclude <stdio.hint main(){ int i, j, k,
C语言基础习题50例(二)6-10
给大家推荐一门大数据Spark入门课程,希望大家喜欢。 习题6 用 号输出字母C的图案。实现思路:单行打印即可。代码如下:cinclude <stdio.h int main (void){ printf("\n"); printf("\n"); printf("\n"); printf("
C语言基础习题50例(三)11-15
你们看出神马了吗(\\^_\^\) 习题11 有一对兔子,从出生后第 3 个月起每个月都生一对兔子,小兔子长到第三个月后每个月又生一对兔子,假如兔子都不死,问每个月的兔子总数为多少实现思路:从第1个月起,兔子对数分别为1、1、2、3、5、8、13、21...,显然是斐波拉契数列。代码如下:cinclude<stdio.hint mai
游戏安全实践的一些思考
移动的游戏能够稳定健康的上线。主要需要依赖以下在四个方面:1.前端展示,或者说客户端正常运行。性能稳定不崩溃,不过热能够稳定运行。2.后端,或者游戏后台服务端的。不但要稳定。还有能在有限的服务器资源下,能承受大量的同时在线用户。而且要让游戏中的每个模块都能够承受承受大量的同时在线用户。3.安全也是重点之中。这既包括客户端,又包括服务端。客户端的安全,包括要防