初识C语言

1. 基本的程序结构

#include <stdio.h>
int main()
{
    printf("hello bit\n");
    printf("he he\n");
    return 0;
}

• 解析

• main函数是程序的入口

一个工程中main函数有且仅有一个

• stdio.h ： 标准输入输出头文件

std - 标准

i - input 输入

o - output 输出

• printf是库函数，库函数的使用，要包含头文件，printf函数需要的头文件是stdio.h，所以有 #include <stdio.h>

• return 0 ： C语言中有一个约定，返回0表示正常返回，返回的是非0，表示异常返回

2. 数据类型

• 单位大小

bit	存储一个二进制位所需的空间
byte	1byte = 8bit
KB	1KB = 1024byte
MB	1MB = 1024KB
GB	1GB = 1024MB
TB	1TB = 1024GB
PB	1PB = 1024TB

• 数据类型

char	字符数据类型	整数	1byte	qw2@	'x' 'a' ' '
short	短整型		2byte	20
int	整形		4byte
long	长整形		4byte或8byte
long long	更长的整形		8byte
float	单精度浮点数	小数	4byte	2.5
double	双精度浮点数		8byte	3.14

 printf("%d\n", sizeof(int));

sizeof(long)≥sizeof(int)就行

3. 变量

• 定义

生活中的有些值是不变的（比如：圆周率，身份证号码，血型等等）

有些值是可变的（比如：年龄，体重，薪资）。

C语言中用常量的概念来表示不变的值,用变量来表示变的值

• 定义变量的方法

类型 变量名

intage = 150;
floatweight = 45.5f;
charch = 'w';

short age = 20
double salary = 10000.5

12.34; 编译器默认以为是double,如果你希望是float类型的，应该写出12.34f

• 变量的命名

只能由字母（包括大写和小写）、数字和下划线（_）组成。

不能以数字开头。

长度不能超过63个字符。

变量名中区分大小写的。

变量名不能使用关键字。

• 变量的分类

#include <stdio.h>
int global = 2019;//全局变量
int main()
{
    int local = 2018;//局部变量
    //下面定义的global会不会有问题？
    int global = 2020;//局部变量
    printf("global = %d\n", global);
    return 0;
}

局部变量和全局变量名字冲突的情况下，局部优先

• 变量的使用

int main()
{
   int age = 10;
   age = age + 1;
   printf("age = %d\n", age);
   return 0;
} 

%d表示后面有一个整数要输出在这个位置上

#include <stdio.h>
int main()
{
    int num1 = 0;
    int num2 = 0;
    int sum = 0;
    printf("输入两个操作数:>");
    scanf("%d %d", &num1, &num2);
    sum = num1 + num2;
    printf("sum = %d\n", sum);
    return 0;
}

• scanf是输入函数&

编译器认为scanf、strcpy、strcat、gets等函数都是不安全的

#define _CRT_SECURE_NO_WARNINGS 1

用everything查找newc++file.cpp，用记事本打开输入上面这段代码，一劳永逸。

• 变量的作用域和生命周期

• 作用域

作用域（scope）是程序设计概念，通常来说，一段程序代码中所用到的名字并不总是有效/可用

的而限定这个名字的可用性的代码范围就是这个名字的作用域。

1. 局部变量的作用域是变量所在的局部范围。

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

• extern 声明外部符号的

exturn int a;
exturn int Add(int, int);

• 生命周期

变量的生命周期指的是变量的创建到变量的销毁之间的一个时间段

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

2. 全局变量的生命周期是：整个程序的生命周期。

4. 常量

• 字面常量

30;
3.14;
"abcdef";
'a';

• const 修饰的常变量

const int num = 100;
num = 200;
printf("%d\n", num);

const int n = 10;
int arr[n] = {1,2,3,4,5,6,7,8,9,10};

报错两次 - const修饰的变量不能被修改，但本质还是变量

C99标准之前，不允许数组的大小用变量指定

C99标准之后，引入变长数组，允许数组的大小用变量指定

• define定义的标识符常量

#define MAX 100
printf("max = %d\n", MAX)

#define MAX 100
MAX = 200

报错，MAX是常量，无法修改。

#define MAX 100
int arr[MAX];

可行，MAX是常量

• 枚举常量

#include <stdio.h>
//举例
enum Sex
{
 MALE,//0
 FEMALE,//1
 SECRET//2
};
//括号中的MALE,FEMALE,SECRET是枚举常量
int main()
{
enum sex s = SECRET;
enum sex s2 = FEMALE;
return 0;
}

枚举常量的默认是从0开始，依次向下递增1的

printf("%d %d %d",MALE,FEMALE,SECRET);

初始值可以改

enum Sex
{
 MALE = 4,//4
 FEMALE,//5
 SECRET//6
};

5. 字符串、转义字符、注释

• 字符

键盘上能敲出来的都是字符

char ch = 'a';
ch = '1';
printf("%c\n",ch);

%d	有符号的整形
%s	字符串
%c	字符

ch的值是97 ->ASCII码值

• 字符串

像这样用双引号引起来的一串字符被称为字符串

\0是字符串结束的标志，且不算做字符串内容

char arr[] = "adcdef";

• strlen是库函数，用来求字符串长度，统计的是字符串中\0之前出现多少个字符

头文件 #include <string.h>

printf("%d\n",strlen(arr1));
printf("%d\n",strlen(arr2));
printf("%d\n",strlen(“abc\0def));/3

printf("abc\ndef");

• 转义字符

我们要在屏幕上打印一个目录： c:\code\test.c

printf("c:\code\test.c");

如何打印一个单引号？

printf('\'');

printf("c:\\code\\test.c");

• \ddd

\后跟1~3个八进制数字 这个八进制数字转化为十进制后，作为的ASCII码值代表的字符

\130 -> 88 -> X

• \xdd

后跟1~2个十六进制数字 这个十六进制数字转化为十进制后，作为的ASCII码值代表的字

\x30 -> 48 -> 0

• \0也是一个转义字符，ASCII值是0

• 注释

勤写注释！

6. 选择语句

C语言是结构化的程序设计语言：顺序结构、选择结构、循环结构

顺序结构
选择结构	if		swich
循环结构	for	while	do while

• if语句

    if (input == 1)
        printf("好offer");
    else
        printf("家里蹲");

7. 循环语句

    while (line < 20)
    {
        printf("写代码\n");
        line++;
    }

8. 函数

int Add(int x, int y)
{
    return(x + y);
}
int main()
{
    int sum = 0;
    int num1 = 0;
    int num2 = 0;
    scanf("%d %d", &num1, &num2);
    sum = Add(num1,num2);
    printf("%d", sum);
    return 0;
}

9. 数组

存放一组相同类型的数据

• 定义数组

int arr[10] = {1,2,3,4,5,6,7,8,9,10};
char ch[5] = {0};//不完全初始化
char ch2[] = {'a','b','c'};
char ch3[] = {0};

• 数组的下标

数组的每个元素都有一个下标，从0开始递增

数组可以通过下标来访问

arr[18]越界访问

10. 操作符

• 算数操作符

• /（除号）

两端的操作数如果都是整数，执行的是整数除法，如果至少有一个操作数是浮点数，执行的是浮点数除法

int a = 7 / 2;//3
float f =7 /  2;//3.000000
float f = 7.0 / 2;//3.5

• %（取模）

两端操作数必须是整数，关注的是除法后的余数

int a = 7 % 2;//商3余1
printf("%d",a);//1

• 移位操作符

>> << 移动的是二进制位

• 位操作符

对一个数的二进制位进行操作

• 赋值操作符

• +=

a = a +5;
a += 5;

• 单目操作符

2 + 3，2是左操作数，3是又操作数 所以+是双目操作符

C语言中0表示假，1表示真

• ！逻辑反操作

int main()
{
    int a = 10;
    if (a)
        printf("hehe\n");
    if (!a)
        printf("haha\n");
    return 0;
}

• sizeof 操作数的类型长度（以字节为单位）

sizeof是操作符，是计算所占内存空间大小

strlen是库函数，只能针对字符串，求字符串长度。计算字符串中\0之前的字符个数

sizeof计算的结构是无符号整数的，对应的打印格式应该是%zu

    int a = 0;
    char c = 'w';
    int arr[10] = { 0 };
    printf("%d\n", sizeof a );
    printf("%d\n", sizeof(int ));
    printf("%d\n",sizeof(c));
    printf("%d\n",sizeof(arr));
    printf("%d\n",sizeof arr );//sizeof后跟类型时（）不能省略

• 计算数组的元素个数

int sz = sizeof(arr) / sizeof(arr[0]);

• --前置、后置++

int a = 10;
int b = ++a;
int c =a++;
ptintf("%d %d %d",a,b,c)

• ()强制类型转换

int a = (int)3.14;

• 关系操作符

• != 用于测试“不相等”

• == 用于测试“相等”

两个字符串是不能用==来判断是否相等的，使用strcmp

#include <string.h>

    if (strcmp(arr1, arr2) == 0)
    {
        printf("==\n");
    }
    else
    {
        printf("!=\n");
    }

• 逻辑操作符

关注的是真假

• && 逻辑与 并且

• | | 逻辑或 或者

    int a = 3;
    int b = 5;
    int c = a && b;
    printf("%d\n", c);//1
    a = 0;
    b = 5;
    c = a && b;
    printf("%d\n", c);//0
    a = 0;
    b = 0;
    c = a && b;
    printf("%d\n", c);//0
    a = 3;
    b = 5;
    c = a || b;
    printf("%d\n", c);//1
    a = 0;
    b = 5;
    c = a || b;
    printf("%d\n", c);//1
    a = 0;
    b = 0;
    c = a || b;
    printf("%d\n", c);//0

• .条件操作符（三目操作符）

if (a > 5)
 b = 3;
else
 b = -3;

（a > 5）？（b = 3):(b = -3);
b = (a > 5 ? 3 : -3);

• 逗号表达式

int a = 3;
int b = 5;
int c = 0;
int d = (a +=2,b=b-c+a,c=a+b);

从左向右依次计算，整个表达式的结果是最后一个表达式的结果

• 下标引用操作符

arr[4]

arr 和 4是[ ] 的两个操作符

4[arr]//可行但不这样写

11. 常见关键字

auto  break   case  char  const   continue  default  do   double else  enum   
extern float  for   goto  if   int   long  register    return   short  signed
sizeof   static struct  switch  typedef union  unsigned   void  volatile  while

1. 关键字是直接使用的，

2. 变量名不能是关键字

• auto - 自动

局部变量都是自动创建，自动销毁的，所以局部变量都是auto修饰的

• const

修饰变量、指针

• extern

是用来声明外部符号的

• register

寄存器关键字，建议作用

• signed

有符号的

• unsigned

无符号的

• static

静态的

1. 修饰局部变量

普通的局部变量是放在内存的栈区上的，进入局部范围，变量创建，出了局部范围变量销毁。

党static修饰局部变量的时候，局部变量是在静态区开辟空间的，这时的局部变量，出了作用域不销毁，下次进去作用域，使用的是上一次遗留的数据。（改变了存储位置，又栈区 ->静态区，使得变量的生命周期发生了变化）

void test()
{
    static int a = 3;
    a++;
    printf("%d ", a);
}
int main()
{
    int i = 0;
    while (i < 10)
    {
        test();
        i++;
    }
    return 0;
}

2. 修饰全局变量

全局变量是具有外部链接属性的，如果全局变量被static修饰，外部链接属性就变成了内部链接属性。其他源文件就没法再通过链接找到这个符号。

static修饰后的全局变量只能在自己所在的.c文件内部使用

3. 修饰函数

函数是具有外部链接属性的，其他源文件想使用函数，只需要正确的声明就可以

如果全局变量被static修饰，外部链接属性就变成了内部链接属性。函数只能在自己所在的.c文件内部使用

• struct

结构体

• typedef

类型重定义

typedef unsigned int uint;
uint a = 0;

• union

联合体/共用体

• volatile

• 数据在计算机上可以存放在哪里？

1. 内存

2. 硬盘

3. 高速缓存

4. 寄存器

12. #define定义常量和宏

• 定义常量

#define MAX 1000
#define STR "abcdef"

• 定义宏

#define ADD(x,y) ((x)+(y))
#define MAX(x,y) ((x)>(y)?(x):(y))
int c = MAX(a, b);

13. 指针

• 内存

内存是电脑上特别重要的存储器，计算机中程序的运行都是在内存中进行的 。

所以为了有效的使用内存，就把内存划分成一个个小的内存单元，每个内存单元的大小是1个字节。

为了能够有效的访问内存的每个单元，就给内存单元进行编号，这些编号被称为该内存单元的地址

编号就是内存单元的地址，编号就是地址，我们把地址也叫指针。

编号=地址=指针

int* pa = &a;
char* pc = &a;//理论上是支持的，但是为什么呢？
*pa = 20;//a =20;

int* 整体是一个类型，整形指针类型

int说明的是pa指向的对象是int类型的

*说明pa是指针变量

a创建好后占用4个字节

&是取地址操作符，&a拿到的是第一个字节的地址

*是解引用操作符(间接访问操作符)，*pa就是通过pa中存放的地址，找到pa指向的空间

• 指针变量的大小

指针变量是用来存放地址的，所以指针变量的大小取决于存储一个地址需要多大空间

int main()
{
    printf("%d\n", sizeof(char *));    //4
    printf("%d\n", sizeof(short *));   //4
    printf("%d\n", sizeof(int *));     //4
    printf("%d\n", sizeof(double *));  //4
    return 0;
}

地址线（32/64） 电信号 ->数字信号

32位环境下：

地址是32个0或1组成的序列，需要32bit的空间来存储

指针大小在32位平台是4个字节，64位平台是8个字节。

14. 结构体

结构体是C语言中特别重要的知识点，结构体使得C语言有能力描述复杂类型。

比如描述学生，学生包含： 名字+年龄+性别+学号 这几项信息。

这里只能使用结构体来描述了

• 结构体的初始化

struct Stu
{
    char name[20];//名字
    int age;      //年龄
    float score;  //分数
};
int main()
{
   struct Stu s1 = {"zhangsan",20,95.5f};
   struct Stu s1 = {"lisi",40,98.5f};

   printf("%s %d %f\n",s1.name,s1.age,s1.score);
   return 0;
}

• 结构体的访问

• 结构体变量.结构体成员

void Print(struct Stu * ps)
{
    //1.结构体变量.结构体成员
    printf("%s %d %f\n", (*ps).name, (*ps).age, (*ps).score);
}

• 结构体指针 ->结构体成员

void Print(struct Stu * ps)
{
    //2.  结构体指针 ->结构体成员
    printf("%s %d %f\n", ps->name, ps->age, ps->score);
}

输入数据到s2中

    scanf("%s %d %f\n", s1.name, &(s1.age), &(s1.score));