C语言程序设计-变量、常量、运算符 (整数浮点字符ASCII定义算术关系逻辑位赋值)

👨‍ Biaoge ⏰于2024-03-07 21:40发布 👓阅读量：125545 🏷️文章类型：【 C语言程序设计 

变量

变量其实只不过是程序可操作的存储区的名称。C 中每个变量都有特定的类型，类型决定了变量存储的大小和布局，该范围内的值都可以存储在内存中，运算符可应用于变量上。

变量的名称可以由字母、数字和下划线字符组成。它必须以字母或下划线开头。大写字母和小写字母是不同的，因为 C 是大小写敏感的。有以下几种基本的变量类型：

char	通常是一个字节（八位）, 这是一个整数类型。
int	整型，4 个字节，取值范围 -2147483648 到 2147483647。
float	单精度浮点值。单精度是这样的格式，1位符号，8位指数，23位小数。
double	双精度浮点值。双精度是1位符号，11位指数，52位小数。
void	表示类型的缺失。

C 语言也允许定义各种其他类型的变量，比如枚举、指针、数组、结构、共用体等等

变量例子：

定义整型变量：

int age;

以上代码中，age 被定义为一个整型变量。

定义浮点型变量：

float salary;

以上代码中，salary 被定义为一个浮点型变量。

定义字符型变量：

char grade;

以上代码中，grade 被定义为一个字符型变量。

定义指针变量：

int *ptr;

以上代码中，ptr 被定义为一个整型指针变量。

定义多个变量：

int    i, j, k;

int i, j, k; 声明并定义了变量 i、j 和 k，这指示编译器创建类型为 int 的名为 i、j、k 的变量。

---

变量初始化

在 C 语言中，变量的初始化是在定义变量的同时为其赋予一个初始值。变量的初始化可以在定义时进行，也可以在后续的代码中进行。

初始化器由一个等号，后跟一个常量表达式组成：

下面列举几个实例：

int x = 10;         // 整型变量 x 初始化为 10
float pi = 3.14;    // 浮点型变量 pi 初始化为 3.14
char ch = 'A';      // 字符型变量 ch 初始化为字符 'A'
extern int d = 3, f = 5;    // d 和 f 的声明与初始化
int d = 3, f = 5;           // 定义并初始化 d 和 f
byte z = 22;                // 定义并初始化 z

---

后续初始化变量：

在变量定义后的代码中，可以使用赋值运算符 = 为变量赋予一个新的值。实例如下：

int x;          // 整型变量x定义
x = 20;         // 变量x初始化为20
float pi;       // 浮点型变量pi定义
pi = 3.14159;   // 变量pi初始化为3.14159
char ch;        // 字符型变量ch定义
ch = 'B';       // 变量ch初始化为字符'B'

需要注意的是，变量在使用之前应该被初始化。未初始化的变量的值是未定义的，可能包含任意的垃圾值。

因此，为了避免不确定的行为和错误，建议在使用变量之前进行初始化。

---

变量不初始化（了解即可）

在 C 语言中，如果变量没有显式初始化，那么它的默认值将取决于该变量的类型和其所在的作用域。

以下是不同类型的变量在没有显式初始化时的默认值：

需要注意的是，局部变量（在函数内部定义的非静态变量）不会自动初始化为默认值，它们的初始值是未定义的（包含垃圾值）。因此，在使用局部变量之前，应该显式地为其赋予一个初始值。

总结起来，C 语言中变量的默认值取决于其类型和作用域。全局变量和静态变量的默认值为 0，字符型变量的默认值为 ，指针变量的默认值为 NULL，而局部变量没有默认值，其初始值是未定义的。

• 整型变量（int、short、long等）：默认值为0。
• 浮点型变量（float、double等）：默认值为0.0。
• 字符型变量（char）：默认值为''，即空字符。
• 指针变量：默认值为NULL，表示指针不指向任何有效的内存地址。
• 数组、结构体、联合等复合类型的变量：它们的元素或成员将按照相应的规则进行默认初始化，这可能包括对元素递归应用默认规则。

---

---

常量

常量是固定值，在程序执行期间不会改变。这些固定的值，又叫做字面量。

常量可以是任何的基本数据类型，比如整数常量、浮点常量、字符常量，或字符串字面值，也有枚举常量。

常量就像是常规的变量，只不过常量的值在定义后不能进行修改。常量可以直接在代码中使用，也可以通过定义常量来使用。

整数常量

整数常量可以是十进制、八进制或十六进制的常量。前缀指定基数：0x 或 0X 表示十六进制，0 表示八进制，不带前缀则默认表示十进制。

整数常量也可以带一个后缀，后缀是 U 和 L 的组合，U 表示无符号整数（unsigned），L 表示长整数（long）。后缀可以是大写，也可以是小写，U 和 L 的顺序任意。

下面列举几个整数常量的实例：疑似考点（PS:注意看标红的前后缀）

212         /* 合法的 */
215u        /* 合法的 */
0xFeeL      /* 合法的 */
078         /* 非法的：8 不是八进制的数字 */
032UU       /* 非法的：不能重复后缀 */

以下是各种类型的整数常量的实例：

85         /* 十进制 */
0213       /* 八进制 */
0x4b       /* 十六进制 */
30         /* 整数 */
30u        /* 无符号整数 */
30l        /* 长整数 */
30ul       /* 无符号长整数 */

整数常量可以带有一个后缀表示数据类型，例如：

int biao = 10;
long biaoLong = 100000L;
unsigned int biaoUnsig = 10U;

---

浮点常量

浮点常量由整数部分、小数点、小数部分和指数部分组成。您可以使用小数形式或者指数形式来表示浮点常量。

当使用小数形式表示时，必须包含整数部分、小数部分，或同时包含两者。当使用指数形式表示时， 必须包含小数点、指数，或同时包含两者。带符号的指数是用 e 或 E 引入的。

下面列举几个浮点常量的实例：疑似考点

3.14159       /* 合法的 */
314159E-5L    /* 合法的 */
510E          /* 非法的：不完整的指数 */
210f          /* 非法的：没有小数或指数 */
.e55          /* 非法的：缺少整数或分数 */

浮点数常量可以带有一个后缀表示数据类型，例如：

float biaoFloat = 3.14f;
double biaoDouble = 3.14159;

---

字符常量

字符常量是括在单引号中，例如，'x' 可以存储在 char 类型的简单变量中。

字符常量可以是一个普通的字符（例如 'x'）、一个转义序列（例如 ' '），或一个通用的字符（例如 'u02C0'）。

在 C 中，有一些特定的字符，当它们前面有反斜杠时，它们就具有特殊的含义，被用来表示如换行符（ ）或制表符（ ）等。下表列出了一些这样的转义序列码：

下面的实例显示了一些转义序列字符：

#include <stdio.h>;
int main() { 
  printf("Hello World
/n") ; 
  return 0; 
}

当上面的代码被编译和执行时，它会产生下列结果：

Hello   World

字符常量的 ASCII 值可以通过强制类型转换转换为整数值。

char biaoChar = 'a';
int biaoAsciiValue = (int) biaoChar; // 将 biaoChar 转换为 ASCII 值 97

 ASCII 值是什么？

科普：在计算机中，所有的数据在存储和运算时都要使用二进制数表示（因为计算机用高电平和低电平分别表示1和0），例如，像a、b、c、d这样的52个字母（包括大写）以及0、1等数字还有一些常用的符号（例如*、#、@等）在计算机中存储时也要使用二进制数来表示，而具体用哪些二进制数字表示哪个符号，当然每个人都可以约定自己的一套（这就叫编码），而大家如果要想互相通信而不造成混乱，那么大家就必须使用相同的编码规则，于是美国有关的标准化组织就出台了ASCII编码

疑似考点：A的ASCII码是65，a的ASCII码是97（其他的可以根据26个字母推算）

---

字符串常量

字符串字面值或常量是括在双引号 " " 中的。一个字符串包含类似于字符常量的字符：普通的字符、转义序列和通用的字符。

您可以使用空格做分隔符，把一个很长的字符串常量进行分行。

下面的实例显示了一些字符串常量。下面这三种形式所显示的字符串是相同的。

"hello, dear"

"hello, 

dear"

"hello, " "d" "ear"

字符串常量在内存中以 null 终止符  结尾。例如：

char biaoString[] = "Hello, world!"; //系统对字符串常量自动加一个 ''

---

定义常量

在 C 中，有两种简单的定义常量的方式：

1. 使用 #define 预处理器： #define 可以在程序中定义一个常量，它在编译时会被替换为其对应的值。
2. 使用 const 关键字：const 关键字用于声明一个只读变量，即该变量的值不能在程序运行时修改。

#define 预处理器

下面的代码定义了一个名为 PI 的常量：

#define PI 3.14159

在程序中使用该常量时，编译器会将所有的 PI 替换为 3.14159。

具体请看下面的实例：

#include <stdio.h>
#define LEN 10 
#define WID 5 
#define NEW '
' 
int main() {
  int area;
  area = LEN * WID;
  printf("%d", area);
  printf("%c", NEW); 
  return 0;
}

当上面的代码被编译和执行时，它会产生下列结果：

50

---

const 关键字

您可以使用 const 前缀声明指定类型的常量

下面的代码定义了一个名为MAX的常量：

const int MAX = 100;

在程序中使用该常量时，其值将始终为100，并且不能被修改。

const 声明常量要在一个语句内完成：

请注意，把常量定义为大写字母形式，是一个很好的编程习惯。

#define 与 const 区别

#define 与 const 这两种方式都可以用来定义常量，选择哪种方式取决于具体的需求和编程习惯。通常情况下，建议使用 const 关键字来定义常量，因为它具有类型检查和作用域的优势，而 #define 仅进行简单的文本替换，可能会导致一些意外的问题。

---

---

运算符（重点内容）

运算符是一种告诉编译器执行特定的数学或逻辑操作的符号。C 语言内置了丰富的运算符，并提供了以下类型的运算符：

• 算术运算符
• 关系运算符
• 逻辑运算符
• 位运算符
• 赋值运算符
• 杂项运算符

算术运算符

PS：就正常的加减乘除！

C 语言支持的所有算术运算符。假设变量 A 的值为 10，变量 B 的值为 20，则：

int A = 10;
int B = 20;

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

示例：

#include <stdio.h>
 
int main()
{
   int a = 21;
   int b = 10;
   int c ;
 
   c = a + b;
   printf("a + b的值是 %d ", c );
   c = a - b;
   printf("a - b的值是 %d ", c );
   c = a * b;
   printf("a * b的值是 %d ", c );
   c = a / b;
   printf("a / b的值是 %d ", c );
   c = a % b;
   
   printf("先赋值后运算： /n") ;
   printf("a % b的值是 %d ", c );
   c = a++;　　　　　　　　// 赋值后再加 1 ，c 为 21，a 为 22
   printf("a++的值是 %d ", c );
   c = a--;　　　　　　　　//赋值后再减 1 ，c 为 22 ，a 为 21
   printf("a--的值是 %d ", c );
   
   printf("先运算后赋值： /n") ;
   a = 10;
   c = ++a; 
   printf("++a 的值是 %d ", c );
   a = 10;
   c = --a; 
   printf("--a 的值是 %d ", c );
  return 0;
}

结果：

a + b的值是 31
a - b的值是 11
a * b的值是 210
a / b的值是 2
先赋值后运算：
a b的值是 1
a++的值是 21
a--的值是 22
先运算后赋值：
++a 的值是 11
--a 的值是 9

---

关系运算符（布尔值）

C 语言支持的所有关系运算符。假设变量 A 的值为 10，变量 B 的值为 20，则：

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

示例：

#include <stdio.h>
 
int main()
{
   int a = 21;
   int b = 10;
   int c ;
 
   if( a == b )
   {
      printf("a 等于 bn" );
   }
   else
   {
      printf("a 不等于 b " );
   }
   if ( a < b )
   {
      printf("a 小于 b " );
   }
   else
   {
      printf("a 不小于 b " );
   }
   if ( a > b )
   {
      printf("a 大于 b " );
   }
   else
   {
      printf("a 不大于 b " );
   }
   /* 改变 a 和 b 的值 */
   a = 5;
   b = 20;
   if ( a <= b )
   {
      printf("a 小于或等于 b " );
   }
   if ( b >= a )
   {
      printf("b 大于或等于 a " );
   }
}

结果：

a 不等于 b
a 不小于 b
a 大于 b
a 小于或等于 b
b 大于或等于 a

---

逻辑运算符

C 语言支持的所有关系逻辑运算符。假设变量 A 的值为 1，变量 B 的值为 0，则：

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

示例：

#include <stdio.h>
 
int main()
{
   int a = 5;
   int b = 20;
   int c ;
 
   if ( a && b )
   {
      printf("条件为真 " );
   }
   if ( a || b )
   {
      printf("条件为真 " );
   }
   /* 改变 a 和 b 的值 */
   a = 0;
   b = 10;
   if ( a && b )
   {
      printf("条件为真 " );
   }
   else
   {
      printf("条件为假 " );
   }
   if ( !(a && b) )
   {
      printf("条件为真 " );
   }
}

结果：

条件为真
条件为真
条件为假
条件为真

---

位运算符

位运算符作用于位，并逐位执行操作。&、 | 和 ^ 的真值表如下所示：

假设变量 A 的值为 60，变量 B 的值为 13（PS：即二级进制为：A:00111100  B:1101）

运算符	描述	实例
&	对两个数的每一位执行逻辑与操作，如果两个相应的位都为 1，则结果为 1，否则为 0。 按位与操作	(A & B) 将得到 12，即为 0000 1100
|	对两个数的每一位执行逻辑或操作，如果两个相应的位都为 0，则结果为 0，否则为 1。 按位或运算符	(A | B) 将得到 61，即为 0011 1101
^	对两个数的每一位执行逻辑异或操作，如果两个相应的位值相同，则结果为 0，否则为 1。 异或运算符	(A ^ B) 将得到 49，即为 0011 0001
~	对操作数的每一位执行逻辑取反操作，即将每一位的 0 变为 1，1 变为 0。取反运算符	(~A ) 将得到 -61，即为 1100 0011，一个有符号二进制数的补码形式。
<<	将操作数的所有位向左移动指定的位数。左移 n 位相当于乘以 2 的 n 次方。 二进制左移运算符。将一个运算对象的各二进制位全部左移若干位（左边的二进制位丢弃，右边补0）。	A << 2 将得到 240，即为 1111 0000
>>	将操作数的所有位向右移动指定的位数。右移n位相当于除以 2 的 n 次方。 二进制右移运算符。将一个数的各二进制位全部右移若干位，正数左补 0，负数左补 1，右边丢弃。	A >> 2 将得到 15，即为 0000 1111

小编汇总：位运算其实不难，做题思路就是：先将数字转化为二进制，然后进行对照即可。

例：5的二进制是0101，4的二进制是0100（不会二进制请看C语言第一章）。

5&4=（就是将二进制每一位进行比较，相同且等于1的位就为1）如图所示：

5|4=（就是将二进制每一位进行比较，相同且等于0的位就为0）图片写错了应该为0101 =>5
5^4=（就是将二进制每一位进行比较，相同的位就为1）
~5=（符号取反，每一位都取反）
5<<1=（每一位向左移动1位，后面用0补充）
5>>1= (每一位向右移动1位，前面用0补充)

---

赋值运算符

C 语言支持的赋值运算符：

运算符	描述	实例
=	简单，把右边操作数的值赋给左边操作数	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 & 三元

C 语言支持的其他一些重要的运算符，包括 sizeof 和 ? :。

运算符	描述	实例
sizeof()	返回变量的大小。	sizeof(a) 将返回 4，其中 a 是整数。
&	返回变量的地址。	&a; 将给出变量的实际地址。
*	指向一个变量。	*a; 将指向一个变量。
? :	条件表达式	如果条件为真 ? 则值为 X : 否则值为 Y

---

C 中的运算符优先级（了解即可）

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

---

本节到此结束，感谢你的观看！