常量、变量

变量

变量，可变的量。变量是用来存储数据的容器。使用变量前需要先声明变量，声明变量就是在向内存申请空间用来存放值。

声明变量的方法

1. 声明单个变量

int main()
{
    // 每种数据类型声明变量的方式；
    char ch = 'a';  
    // 向内存申请1个字节的空间命名为ch，里面放入字符A；
    short num = 0;  
    // 向内存申请2个字节的空间命名为num，里面存放整形数值0；
    int age = 18;   
    // 向内存申请4个字节的空间命名为age，里面放入整形数值18；
    long longNum = 10000;
    // 向内存申请4个字节的空间命名为longNum，里面放入整形数值10000；
    long long maxNum = 99999999;
    // 向内存申请了8个字节的空间名为maxNum，里面放入整形数值99999999；
    // int、long、long long 存放的都是整形只是所占内存空间大小不同。
    float f = 3.14;
    // 向内存申请了4个字节的空间命名为f，里面存放浮点型数值3.14;
    double lf = 3.1415926;
    // 向内存盛情了8个字节的空间命名为lf,里面存放浮点型数值3.1415926；
    return 0; 
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

2. 声明多个变量，通过逗号分隔

int x = 0,y = 1;
1

3. 等号 “=” 是赋值操作符，用于将右侧的值赋给左侧的变量。

4. 双等号 == 才是关系操作符，用于测试 == 两边是否相等， 常用于分支、循环语句的判断条件。

   经常容易犯的错误将 == 写成 = ，如果出现在判断条件中，那么这个语句永真(前提是数据类型要一致)；

   可以将变量放在 == 右侧，字面常量放在 == 左边，这样即使少写 一个 = 系统也会报错。

   int main()
   {
       int n = 5;
       int ret = 5 == n?1:0;
       return 0;
   }
   
   
   1
   2
   3
   4
   5
   6
   7
   8

变量的分类

变量分为全局变量和局部变量

全局变量

定义在代码块{}之外，不被{}包含的变量。

局部变量

定义在代码块{}内部的变量。

#include <stdio.h>

int global = 2021; // 全局变量

int main() 
{
int local = 2019; // 局部变量
int global = 2020; // 局部变量 
// 局部变量和全局变量名字相同时，可以同时存在，局部变量优先(建议不要相同)
printf("global = %d\n", global); // printf 2020(就近原则)
return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12

变量的作用域和生命周期

1. 作用域是指变量能被使用的范围。

2. 生命周期是指程序在运行时，变量从创建到销毁的一个时间段。

局部变量

局部变量的作用域在局部变量所在的代码块{}中

局部变量的生命周期：进作用域生命周期开始，出作用域生命周期结束。

#include <stdio.h>
// 1. 局部变量的作用域在局部变量所在的代码块内部
int main()
{
{
int age = 0; // age 的作用域在第二个{}内
printf("age = %d\n", age);// 此时在相同作用域可以使用
}
printf("age = %d\n", age); // 此时age不在外层作用域中，无法使用
return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12

#include <stdio.h>
// 2. 外层代码块{}的变量可以被其中的内层代码块{}调用
int main()
{
    int age = 0; // age 的作用域在外层代码块{}中，包含内部的所有代码块
{

printf("age = %d\n", age);// age 可以被使用
}
return 0;
}
1
2
3
4
5
6
7
8
9
10
11

#include <stdio.h>
// 3. 局部变量的生命周期： 进作用域生命周期开始，出作用域结束;
int main()
{

    {// 进作用域
         int a = 10;
        printf("a = %d\n", a); 
        
    }// 出作用域
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12

全局变量

全局变量的作用域是整个工程。

全局变量的生命周期就是整个工程的生命周期。

#include <stdio.h>
// 源文件 test01.c 
int global = 2021; // 全局变量
// 可以把全局变变量的生命周期看main函数的生命周期
int main()
{
    extern int g_val; //  声明外部变量
    printf("g_val = %d\n", g_val) 
    // 全局变量为外部源文件(本工程内的)也能使用，需要声明外部变量
    printf("%d\n", global);
    
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

// 源文件 test02.c
// 假如在外部源文件声明一个全局变量 
int g_val = 2020; (外部源文件全局变量);
1
2
3

常量

常量不可变的量。

常量分为字面常量、 const修饰的常变量、#define定义的标识符常量、枚举常量。

字面常量

#include <stdio.h>
int main()
{
// 直接写出一个值
3;   // 字面常量
100; // 字面常量
3.14;// 字面常量
}
1
2
3
4
5
6
7
8

const 修饰的常变量

const是具有常属性的变量，与常量有区别。

#include <stdio.h>
int main()
{
const int num1 = 4;
// num1 是const修饰的常变量，无法修改
printf("%d\n", num1); // 4
num1 = 8; // error C2166 : 左值指定 const 对象
// 常变量：无法修改(具有常属性)，本质还是变量
const int n = 10; 
    // n不是常量，只是具有常属性，不能被修改
int arr[n] = { 0 }; 
// test.c(39): error C2057: 应输入常量表达式
// 从报错可以看出 const修饰的n是变量不是常量
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

#define 定义的标识符常量

#define MAX 10
#include <stdio.h>
int main()
{
int arr[MAX] = { 0 };
printf("%d\n", MAX); // 10;
return 0;
}
// 数组[]里需要输入常量，这里将MAX输入进去，未报错可以正常运行
// 说明#define 定义的 MAX 是常量
1
2
3
4
5
6
7
8
9
10

枚举常量

枚举：一一列举

枚举关键字 enum

#include <stdio.h>
// 创建枚举常量类型，里面的值为枚举常量
enum Sex
{
        // 枚举常量的类型是整形
MALE,  // 如果不初始化默认从0开始
FEMALE, // 1
SECRET  // 2
};
int main()
{
    enum Sex m =MALE; // 将枚举常量MALE赋值给m
    enum Sex f =FEMALE; // 将枚举常量FEMALE赋值给f
    enum Sex s =SECRET; // 将枚举常量SECRET赋值给s
    // m/f/s 是变量可以修改值
    printf("%d\n", MALE);   // 0 
printf("%d\n", FEMALE); // 1
printf("%d\n", SECRET); // 2
    // 枚举变量不可以修改  
    SECRET = 3; 
// error C2106 : “ = ” : 左操作数必须为左值
printf("%d\n", m); // 0
printf("%d\n", f); // 1
printf("%d\n", s); // 2
// printf m/f/s 的输出结果为对应枚举常量的值
   return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

字符串、转义字符、注释

字符串

C语言没有字符串类型，但是由**“”引起的一串字符叫做字符串**，也被称为字符串字面值(String Literal)。

字符串的结束标志是转义字符**\0** 。在计算字符串长度的时候， \0 是结束标志，不算做字符串的长度。
但是在计算字符串大小时，是计算\0的。

创建字符串数组

#include <stdio.h>
#include <string.h>
int main() 
{
    // 可以将字符串放入数组中
char arr[] = "abc"; 
    // 如果以""字符串字面值来初始化arr数组，后面默认加结束标志\0,隐藏在末尾。
    char arr1[] = {'a','b','c'}; 
    // 如果以''字符类型来初始化arr数组，后面不加\0
    
    char arr2[] = {'a', 'b', 'c', '\0'};
printf("%s\n", arr);  // abc
    printf("%s\n", arr1)  // abc烫烫烫烫蘟bc,因为没有加\0 结束标志
    printf("%s\n", arr2); // abc
            
    // strlen() 计算字符串长度 
printf("%d\n", strlen(arr));  // 3
printf("%d\n", strlen(arr1)); // 15
printf("%d\n", strlen(arr2)); // 3
    // arr1因为后面没有结束标志\0，所以会随机生成字符直到遇到00000000 也就是 \0 才结束
    
    // sizeof() 计算字符串大小
    printf("%d\n", sizeof(arr));  // 4
printf("%d\n", sizeof(arr1)); // 3
printf("%d\n", sizeof(arr2)); // 4
    // 下面会区分strlen()与sizeof()的区别
     return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

strlen()和sizeof的区别

strlen()计算字符串长度由\0决定,函数什么时候遇到\0什么时候结束计算，并且不会计算\0。

sizeof是运算符，用来计算操作数在内存中占用的字节数。在字符串数组中，有多少字符就会返回多少字节(char占用1字节)，\0也会被计算。

int main()
{
char str[100] = "abcdefg";
printf("length = %d\n", strlen(str));
printf("size = %d\n", sizeof(str));
return 0;
}
1
2
3
4
5
6
7

单引号和双引号的区别

用单引号引起的一个字符实际上代表一个整数，整数值对应于该字符在编译器采用的字符集中的序列值。而一般我们的编译器采用的都是ASCII字符集。

而用双引号引起的字符串，代表的是一个指向无名数组起始字符的指针。

    // char - 字符类型；
    // 单引号引起的单个字符 --> 字符
    // 'a'  // 字符a
    // ' '  // 空字符
    // 双引号引起的一串字符 --> 字符串
    // "abcdef"; // 字符串字面值
    // "";      // 空字符串
1
2
3
4
5
6
7

ASCII 表

• A – 65 后面的字母面以此类推 01000001
• a – 97 后面的字母面以此类推 01100001
• 大写和小写对应的字母相差32
• 48-57 为0-9有序上升
  

  转义字符

int main()
{
printf("abc\n");                   // \n 换行符
printf("\tabc\n");                 // \t 水平制表符tab         // 
printf("c;\\test\\32\\test.c\n");  // \\ 表示一个反斜杠
printf("%c\n", '\'');              // \' 表示 '
printf("%s\n", "\"");              // \" 表示 "

    // 下面的strlen输出数值为多少？
    printf("%d\n", strlen("c:\test\32\test.c"));
// 13个字符 \t 算1个字符 \32 算1个字符 \t 算一个字符
    // \32 -- 是2个 8进制数字  \ddd转义字符
    //  32 作为8进制代表的 在ASCII码表上相对应得10进制数代表的字符
    // 32(8进制) == 26(10进制) 对应得ASCII值代表的字符是→
    
    // \ddd  ddd表示1~3个八进制的数字。
    printf("\32\n");   // →
printf("\132\n");  //  Z
    
    // \xdd  dd表示2个十六进制数字。
    printf("%c\n", '\x7e\n');  //  ~  126(10进制)
    printf("%c\n", '\x61\n');  //  a   97(10进制)
return 0;
    
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

注释

/* C语言注释风格*/
/*缺点不能嵌套注释*/
// c++注释风格
// 可以注释一行也可以注释多行

// VS快捷键
// ctrl + k + c 注释
// ctrl + k + u 取消注释
1
2
3
4
5
6
7
8