C语言基础知识总结

C语言基础知识总结

• 目录
• • 1、Hello 解释
  • 2、C语言中的数据类型
  • 3、基本类型
  • 4、单位换算
  • 5、变量和常量
  • 6、标识符的命名规范
  • 7、C语言中的运算符
  • • 练习1：实现两个变量的值互换，至少用两种方法实现；
    • 练习2 ：使用scanf 函数从键盘输入一个三位数，编写程序输出 个位 十位 百位 之和；
  • 8、C语言中有三种基本结构
  • • 8.1、顺序结构
    • 8.2、选择结构
    • • 1、if else 语句
      • • C语言中，真假是怎么界定的呢？
        • 练习3：学生成绩管理系统
        • 练习4：排序，输入三个数，按照从小到大的顺序进行排序，并且输出
      • 2、switch case语句
      • • 练习5：用switch case 语句实现学生成绩管理系统
    • 8.3、循环结构
    • • 1、while循环
      • • 练习6：实现 1 ~ 100 的累加，并输出结果；
      • 2、do while循环
      • 3、for循环
      • • 练习7：使用for 循环实现1~100 的累加，并输出结果；
        • 死循环的写法
  • 9、构造类型
  • • 1、数组
    • • 1.1、概念
      • 1.2、格式
      • 1.3、一维数组的访问及相关性质
      • 1.4、一维数组的初始化
      • 练习：定义一个10个长度的数组，并且完全初始化，编写代码，找出数组中最大的元素及其下标；
    • 2、指针
    • • 指针和数组之间的关系
      • 练习：使用指针，实现计算字符串的长度
      • 练习： 实现字符串的拼接；将字符串str2 接到str1 后面；
    • 3、结构体
    • • 练习：定义一个学生结构体，包含学生的基本信息，（姓名，学号，年龄，分数），在终端录入学生信息，录完之后，将信息全部输出；
  • 10、函数
  • • 练习：封装一个函数，实现 1 ~ n 累加的和，返回和值；

目录 1、Hello 解释

#include //包含 头文件
//  # 预处理符号
//  main函数，主函数，程序入口函数
//  int 返回值类型，
//  main 函数名
//  () 里面 是函数的形参列表
// void  代表着没有形参 ，可以不写
int main(void)
{
    // {} 里面是函数体，要执行的内容
//  printf();  函数的调用
//  格式化打印输出函数
//  n 这是一个字符，换行符
    printf("Hello World!n");
//  return  返回值 ，程序运行成功 返回 0
//  如果函数没有返回值，返回值类型 写void ,必须写
//  每一行代码的最后都需要加一个分号；
    return 0;
}

2、C语言中的数据类型

数据类型： 基本类型，构造类型，指针类型，空类型；

3、基本类型

总共有6种；

• short ：短整型 占2字节
• int ：整型 占4字节
• long ：长整型 占4字节（在32位系统），占8字节（在64位系统）
• char ：字符型 占1字节
• float ：单精度浮点型 占4字节
• double ：双精度浮点型 占8字节

基本类型的实质：指在内存上开辟多大字节的空间；
验证： sizeof(); 关键字 ：测占内存的字节
整型存储的是整数，字符型存储的是字符，就是键盘上输入的字符；
浮点型存储的是小数，单精度代表能够精确到小数点后6位，双精度能够精确到小数点后15位；

4、单位换算

内存的基本单位 ：字节 byte
内存的最小单位 ： 位 bit
数据在内存中，是以二进制的形式存储的；
单位换算;

1 byte = 8 bit
1KB    = 1024 byte
1MB   =  1024 KB
1GB   =   1024 MB

5、变量和常量

程序运行中，值可以发生改变的量，就叫做变量，变量用来存储数据的；
变量的大小： 由变量的类型决定
变量的名字： 是一个标识符，要符合标识符的命名规范
定义变量的格式：
（存储类型auto） 数据类型 变量名;

• 常量：与变量对应，在程序运行中，值不会发生改变的量，就是常量；
• 常量 一般是用来给变量赋值，或者是参与比较；
• 常量分类：
  整型常量 用%d 打印
  浮点型常量 float 用%f 打印，double %lf 打印
  字符型常量 %c 打印 代码中，用单引号 引起来的内容都是字符
  字符串型常量 %s 打印 代码中，用双引号 引引来的内容都是字符串

#include 
int main(void)
{
    //int a;//定义变量，给变量赋值
    //a = 10;
    //在定义变量的同时进行变量赋值，叫做初始化
    //int b = 10;
    //两个变量之间可以相互赋值
    int a = 10;
    int b = 20;
    printf("a = %dn",a);
    printf("b = %dn",b);
    a = b;//单个的等于号，叫做赋值运算符，意思是将b 的值赋给 a;
    //另外，允许在一行定义多个变量，变量之间用 逗号 隔开，末尾加分号
    printf("a = %dn",a);
    //int c,d = 20,e,f;
    return 0;
}

6、标识符的命名规范

1、标识符是由数字、字母、下划线组成；
2、不能够以数字开头；
3、不能够和关键字冲突，关键字和标识符都是严格区分大小写的；
注意：标识符：变量名，函数名，数组名，结构体名…。
关键字：

1 char short int long float double enum struct union void signed unsigned 12个数据类型
2 auto register static extern const volatile 6个存储类型
3 sizeof
4 typedef
5 if else switch case break default for while do goto return continue 12个基本结构相关

7、C语言中的运算符

运算符 是一个符号，作用：多个数值之间进行运算使用；
分类：

• 算术运算符： + - * / %(模除，就是取余数) ++ –
• 关系运算符： > < >= <= != ==(l两个等于号才是关系运算符)
• 逻辑运算符： && || ！
• 赋值运算符： = += -= *= /=（复合）
• 条件运算符： C语言中唯一一个三目运算符 ？ ：
• 位运算符[[ ： & | ^ ~ << >>
• 逗号运算符： ，
• sizeof运算符： 用来计算变量的大小；
• 注意事项：
  算术运算符，%模除，左右操作数必须是整数；
  自增自减运算符 ++ –

int a = 10;
a++;  <==> a = a + 1;
a--;  <==> a = a - 1;
++a;  <==> a = a + 1;
--a;  <==> a = a - 1;

前++ 和 前--  也就是 ++a;--a;
a 本身的值会 +1 或者 -1；表达式的结果也会 +1 或者 -1；
后++ 和 后--  也就是 a++;a--;
a 本身的值会 +1 或者 -1；表达式的结果还是 a++ 或者 a-- 之前的值；

#include 
int main(void)
{
    int a = 10;
    int b = 10;
    printf("a = %d  a++ = %dn",a,a++);
    //逗号运算符，右边的表达式会影响左边的表达式
    printf("a = %d  ++a = %dn",b,++b);
    return 0;
}

位运算符
针对二进制数的，系统在对二进制数进行运算的时候，会对要运算的两个数，进行一个右端对齐，然后才进行运算；

& 按位与： 全1为1；有0为0；
| 按位或： 全0为0；有1为1；
^ 按位异或：相同为0；不同为1；
~ 按位取反：0变1；1变0；
<< 左移：左边丢弃，右边补0；
>> 右移：正数左边补0；负数左边补1；右边丢弃；

    1010    10    
    1111    15    
&   1010    10    |    1111    ^    0101

练习1：实现两个变量的值互换，至少用两种方法实现；

int main(void)
{
    int a = 13;
    int b = 24;
    int temp = 0;
    printf("a = %d  b = %dn",a,b);
   
    //异或法
    a = a ^ b;
    b = a ^ b;
    a = a ^ b;
    printf("a = %d  b = %dn",a,b);
    return 0;
}

练习2 ：使用scanf 函数从键盘输入一个三位数，编写程序输出 个位 十位 百位 之和；

如： 123 ------->> 1 + 2 + 3 = 6;

• scanf(输入格式，变量地址); 格式化输入函数
  int a;
  scanf(“%d”,&a);

#include 
int main(void)
{
  int g,s,b,input_num,sum;
  printf("please input sanweishu >> ");
  scanf("%d",&input_num);
  g = input_num % 10;
  s = input_num / 10 % 10;
  b = input_num / 100;
  sum = g + s + b;
  printf("g = %d s = %d b = %d sum = %dn",g,s,b,sum);
    return 0;
}

8、C语言中有三种基本结构 8.1、顺序结构

在C语言中，程序按照从上到下顺序执行；

8.2、选择结构 1、if else 语句

if(表达式)
{
    //代码块1
}
else
{
    //代码块2
}
//当表达式为真，执行代码块1，表达式为假，执行代码块2；

C语言中，真假是怎么界定的呢？

非0 为 真；0 为假；
-1 -100 真；
0 为假；
1 100 真；
逻辑运算符： && || ！
&&：有假即为假，全真才为真；
|| ：有真即为真，全假才为假；
! : 真假转换；
int i = 10;
if(i > 1 && i < 20)//判定条件为真
if(i > 1 || i < 10)//判定条件为真

int i = 10;
if(i > 1 && i < 20)//判定条件为真
if(i > 1 || i < 10)//判定条件为真

短路原则：
在逻辑与中，当第一个条件为假时，不判断第二个条件；
在逻辑或中，当第一个条件为真时，不判断第二个条件；
嵌套形式

if(表达式1)
{
    if(表达式2)
    {
        //代码块1    
    }
    else
    {
        //代码块2    
    }
}
else
{
    //代码块3
}
//当表达式1为真时，判断表达式2，如果表达式2为真，执行代码块1，如果表达式2为假，执行代码块2，
//当表达式1为假时，执行代码块3；

注意：如果代码块只有一条语句，可以不写花括号 {}

练习3：学生成绩管理系统

要求输入成绩，判断
[90，100] A
[80，90) B
[70，80) C
[0，70) D
其他成绩，输出错误；

#include 
int main(void)
{
    int score;
    while(1)
    {
        printf("please input score >> ");
        scanf("%d",&score);
        if(score > 90 && score <= 100)
            printf("score is An");
        if(score > 80 && score <= 90)
            printf("score is Bn");
        if(score > 70 && score <= 80)
            printf("score is Cn");
        if(score >= 0 && score <= 70)
            printf("score is Dn");
        if(score > 100 || score < 0)
            printf("score is errorn");
    }
    return 0;
}

练习4：排序，输入三个数，按照从小到大的顺序进行排序，并且输出

a = 10;b = 40; c = 30;
输出： a = 10 b = 30 c = 40

#include 
int main(void)
{
    int a,b,c,temp;
    scanf("%d%d%d",&a,&b,&c);
    if(a >= b)
    {
        temp = a;
        a = b;
        b = temp;
    }//a 中存储的是 a b 中较小的值
    if(a >= c)
    {
        temp = a;
        a = c;
        c = temp;
    }//a 中存储的是a c 中较小的值
    //a 现在就是最小的值
    if(b >= c)
    {
        temp = b;
        b = c;
        c = temp;
    }//b 中存储的是b c 中较小的值
    printf("a = %d b = %d c = %dn",a,b,c);
    return 0;
}

2、switch case语句

switch(算数表达式)
{
     case 结果1:
     //代码块1
     break;
    case 结果2:
        //代码块2
    break;
    default:// 其他结果
    //代码块3
    break;
}
//算数表达式，一般为变量，或者是一个能够算出结果的表达式，也可以是单个字符；
//如果算数表达式的结果为结果1，执行代码块1，以此类推；
//如果不满足所有列出的结果，会执行default 后的代码块；
//注意：每一个结果后面，都要加上break；如果没写break,代码会向下执行，知道遇到break 跳出分支，或者执行到代码末尾；
//case 后面的结果，不能为小数；

练习5：用switch case 语句实现学生成绩管理系统

#include 
int main(void)
{
    int score;
    while(1)
    {
        printf("please input score >> ");
        scanf("%d",&score);
        if(score < 0 || score > 100)
            printf("score is errorn");
        else
        {
            switch(score/10)
            {
                case 10:printf("score is An");break;
                case 9:printf("score is An");break;
                case 8:printf("score is Bn");break;
                case 7:printf("score is Cn");break;
                default:printf("score is Dn");break;
            }
        }
    }
    return 0;
}

8.3、循环结构 1、while循环

while(表达式)
{
    //循环体
}
//当表达式成立的时候，执行循环体
//循环体，就是要执行的代码
//while(1) 死循环

练习6：实现 1 ~ 100 的累加，并输出结果；

#include 
int main(void)
{
  int i = 100,sum = 0;//定义变量记得初始化，补初始化的话，变量里面的值可能不对
  while(i)
  {
    sum += i--;
    //sum += i;
    //i--;
  }
  printf("sum = %d i = %dn",sum,i);
    return 0;
}

2、do while循环

do
{
    //循环体
}while(表达式);
//和while唯一的区别就是，先执行一次循环体，然后再判断表达式
//注意：  最后while 有一个分号 ;

3、for循环

for(表达式1;表达式2;表达式3)
{
    //循环体
}
//先执行表达式1，表达式1 一般为赋值语句，或者是定义变量
//再执行表达式2，表达式2 为判断语句，如果表达式2为真，执行循环体，如果表达式2为假，结束循环；
//执行完表达式2，再执行表达式3；完事儿之后，接着判断表达式2，
//如果表达式2依旧为真，还执行表达式3...2、3循环，知道表达式2为假，结束循环
//表达式3，一般为步长；改变循环变量的值；

练习7：使用for 循环实现1~100 的累加，并输出结果；

#include 
int main(void)
{
  int i,sum = 0;
    for(i = 100;i > 0;i--)
    {
        sum += i;
    }
    printf("sum = %d i = %dn",sum,i);
    return 0;
}

死循环的写法

所谓的死循环，就是说条件一直不满足，循环不退出的情况；

while(1){}

for(;;)//里面表示式可以不写，但是两个分号必须得写
{
}

9、构造类型

是对于基本类型得一种应用，是给用户使用的；基本类型对于物体的描述比较单一，构造类型可以对物体有跟多的描述；
构造类型有三种，分别是 数组、结构体、共用体；

1、数组 1.1、概念

概念：数组是用来保存一组相同类型的数据的顺序集合；
数组中保存的每一个数据都叫做数组的一个元素；
数组需要在内存中开辟一块连续的空间，每个元素之间的地址都是连续的；
我们只讲一维数组，所谓的一维数组，就是说只有一个下标的数组；

1.2、格式

（存储类型） 数据类型 数组名[下标]；
存储类型：默认是auto
数组中元素的类型可以是基本类型，也可以是构造类型（除数组）；
数组名：是一个标识符，必须符合标识符的命名规范；
下标：在定义数组的时候，只是一个常量，表示的是数组的长度；在使用数组的时候，下标表示数组的第几位（从0开始），可以是常量，也可以是变量，还可以是一个能够算出结果的表达式；

1.3、一维数组的访问及相关性质

#include 
int main(void)
{
    //定义了一个数组名为str1的数组，数组里面有5个 int 类型的数据；
    int str1[5];
    int str2[5];
    int i;
    //对数组赋值
    str1[0] = 10;
    str1[1] = 20;
    str1[2] = 30;
    str1[3] = 40;
    str1[4] = 50;
    //读取数据
    printf("str[0] = %dn",str1[0]);
    printf("str[1] = %dn",str1[1]);
    printf("str[2] = %dn",str1[2]);
    printf("str[3] = %dn",str1[3]);
    printf("str[4] = %dn",str1[4]);
    //一维数组中的元素地址连续
    //打印地址 %p, &可以获取变量的地址；
    printf("str[0] = %pn",&str1[0]);
    printf("str[1] = %pn",&str1[1]);
    printf("str[2] = %pn",&str1[2]);
    printf("str[3] = %pn",&str1[3]);
    printf("str[4] = %pn",&str1[4]);
    //一维数组的遍历
    for(i = 0;i < 5;i++)
    {
        printf("str1[%d] = %dn",i,str1[i]);
        //注意：下标不要越界；
        //如果越界，编译器不会检查错误，但是一旦访问到非法内存，就会出现错误
    }
    //一维数组所占内存的大小
    printf("sizeof(str1) = %dn",sizeof(str1));
    //有可能不确定数组元素的个数，怎么遍历
    for(i = 0;i < sizeof(str1) / sizeof(int);i++)
    {
        printf("str1[%d] = %dn",i,str1[i]);
    }
    //数组名是一个地址，并且是数组所有元素的首地址
    //地址是一个常量，所以数组名不能够被赋值，更不能做 str1++ 操作


    //如果数组已经定义好了，就不能通过数组名直接整体赋值
    for(i = 0;i < 5;i++)
    {
        str2[i] = str1[i];
        printf("str2[%d] = %dn",i,str2[i]);
    }
    return 0;
}

1.4、一维数组的初始化

#include 
int main(void)
{   //在定义的时候
    //数组的完全初始化
    //如果数组中元素没有初始化，那么里面的值就是随机值
    int s[5] = {10,20,30,40,50};
    //完全初始化为 0
    int s2[5] = {0};
    //不完全初始化
    //未被初始化的元素会被默认初始化为0
    int s3[5] = {10,20};
    //不在定义的时候，不能够用花括号初始化
    return 0;
}

练习：定义一个10个长度的数组，并且完全初始化，编写代码，找出数组中最大的元素及其下标；

#include 
int main(void)
{
    int s[10] = {12,34,54,87,77,44,76,9,66,10};
    int max_index = 0;//假设第0 位为最大的元素
    int i;
    for(i = 1;i < 10;i++)//i 从第1 位开始，是自己不参与比较的意思
    {
        if(s[i] > s[max_index])
        {
            max_index = i;
        }
    }
    printf("max_num : %d max_index: %dn",s[max_index],max_index);
    return 0;
}

2、指针

概念：内存中每个字节的空间都有一个编号，这个编号就叫做地址，也叫做指针；也就是说指针其实就是地址编号，专门用来保存指针的变量，就是指针变量，我们平时说的指针，就是指针变量，地址编号叫做地址；

格式：
数据类型 *指针变量名;(一定要初始化)

注意事项：

• （ * ）号，在定义指针的时候，只起到标识作用，目的是为了和普通变量区分开
• p 才是指针；
• （ * ）号，在使用的时候，表示的是取到所保存地址上的值；
• *p 和 a 是等价的；
• 指针在定义的时候，一定要初始化，指针的出现，必须指向某处，或者指向NULL，否则他就会瞎指，这种情况被称为野指针，野指针是有害的；

#include 
int main(void)
{
    //内存中每个字节都有一个编号，叫做地址
    //定义变量时，系统会根据变量的类型给变量分配合适大小的空间用来保存数据
    int a = 10;
    //使用 & 获取变量a 的地址
    int *p = &a;//用a 的地址初始化指针 p
    printf("&a = %pn",&a);//打印地址用 %p
    printf("p = %pn",p);//指针里面存储的是地址，所以用%p 打印
    //常量 是没有地址的
    //int *p2 = &100;//错误
    printf("&p = %pn",&p);//指针的地址，和变量a 的地址没有关系，使用单独的内存存储指针
    printf("a = %d *p = %dn",a,*p);//对指针取 * 操作，可以取到所存地址上的值
    *p = 20;//通过*p 修改变量的值，当指针 p 指向 a 所在的内存时，*p等价于变量 a;
    printf("a = %d *p = %dn",a,*p);


    //指针只能保存已经分配好的地址，不能够自己分配
   
    printf("psize = %dn",sizeof(p));//指针的大小固定，在32位系统中是4个字节，在64位系统中是8个字节；
    return 0;
}

指针和数组之间的关系

#include 
int main(void)
{
    int s[6] = {10,20,30,40,50,60};
    int i;
    printf("s[0] = %dn",s[0]);
    printf("s[3] = %dn",s[3]);
    //数组名就是一个地址，是数组的首地址
    //通过下标访问数组成员的本质，就是以数组名（首地址）为基准，偏移几个数据元素，然后取值；
    printf("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!n");
    printf("s = %p   *s = %dn",s,*s);
    printf("s+3 = %p   *(s+3) = %d   s[4] = %dn",s+3,*(s+3),s[4]);
    printf("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!n");
    int *p = s;//将数组的首地址（数组名）赋给指针 p;
    int *p2 = &s[0];
    //int *p3 = &s;//不要使用，有问题
    printf("p = %p  p2 = %pn",p,p2);
    //这三种方法都可以取到首地址
    //当指针保存了数组的首地址之后
    // s[i] <==> *(s+i) <==> *(p+i) <==> p[i]
    printf("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!n");
    printf("p = %p  *p = %dn",p,*p);
    printf("p+3 = %p   *(p+3) = %d  p[4] = %dn",p+3,*(p+3),p[4]);
    printf("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!n");
       for(i = 0;i < 6;i++)
       {
           //printf("s[%d] = %dn",i,s[i]);
           //printf("s[%d] = %dn",i,p[i]);
           //printf("s[%d] = %dn",i,*(s+i));
           printf("s[%d] = %dn",i,*(p+i));
       }
       //p 是指针变量，所以可以被赋值，p = p + 1;意思是说 指针向后偏移一位；
       //
       p++;//偏移的是一个数据类型
       printf("*p++ = %dn",*p);
       //s++;// s 是一个地址常量，不可以被赋值；
    return 0;
}

练习：使用指针，实现计算字符串的长度

#include 
int main(void)
{
    char str[128] = {0};
    char *p = str;
    int count = 0;
    printf("please input  string >> ");
    scanf("%s",str);
    while(*p != '')// *p 是字符串的第一个字符
    {
        p++;//指针的指向向后偏移一位；
        count++;//计数 +1
    }
    printf("slen = %dn",count);
    return 0;
}

练习： 实现字符串的拼接；将字符串str2 接到str1 后面；

str1[] = “hello”;
str2[] = “world”;
…
str1[] = “helloworld”;
// str[] = “hello world”;

#include 
int main(void)
{
    char str1[128] = {0};
    char str2[128] = {0};
    char *p = str1;
    char *q = str2;
    printf("please input str1 >> ");
    //scanf("%s",str1);
    gets(str1);
    printf("please input str2 >> ");
    //scanf("%s",str2);
    gets(str2);
    while( *p != '')
    {
        p++;
    }//先找到str1 的 ''
    while(*q != '')
    {
        *p++ = *q++;
        /
    //第二种定义结构体类型的方法
    //借助 关键字 typedef 作用：起别名
    typedef struct student
    {
        char name[20];
        int age;
        int score;
    }stu_t;
    stu_t s1;
    s1.age = 22;
    s1.score = 99;
    strcpy(s1.name,"zhangs");
    printf("%dn",s1.age);
    printf("%dn",s1.score);
    printf("%sn",s1.name);
    return 0;
}

练习：定义一个学生结构体，包含学生的基本信息，（姓名，学号，年龄，分数），在终端录入学生信息，录完之后，将信息全部输出；

#include 
int main(void)
{
    struct student
    {
        char name[20];//结构体类型里面一定不要初始化
        int id;
        int age;
        int score;
    };
    while(1)
    {
        struct student stu;
        printf("请输入学生的姓名：");
        scanf("%s",stu.name);
        printf("请输入学生的学号：");
        scanf("%d",&stu.id);
        printf("请输入学生的年龄：");
        scanf("%d",&stu.age);
        printf("请输入学生的成绩：");
        scanf("%d",&stu.score);
        printf("该学生的信息为：n姓名：%st学号：%dn年龄：%dt成绩：%dn",stu.name,stu.id,stu.age,stu.score);
    }
    return 0;
}

10、函数

概念：将能够实现一定功能的代码块封装成一个整体，这个整体就是函数，每次使用这些代码块的时候，只需要调用相应的函数即可；

格式：
返回值类型 函数名(形参列表)
{
    //函数体；
}
注意：如果说没有返回值，返回值类型填void ,没有形参列表，可以空着或者填void
函数的三要素，声明，实现，调用；

//函数的声明
int add(int a,int b);
//函数的实现
int add(int a,int b)
{
    int c;
    c = a + b;
    return c;
} 
//函数的实现不能够写在main 函数中；
int main(){
    int x = 20;
    int y = 30;
    int z;
    //函数的调用
    z = add(x,y);                
}

练习：封装一个函数，实现 1 ~ n 累加的和，返回和值；

#include
using namespace std;
typedef long long int ll;

ll getsum(ll n){
    ll sum=0;
    for(int i=1;i<=n;i++){
        sum+=i;
    }
    return sum;
}

int main(void)
{
    ll n;
    cin>>n;
    cout<