03.C语言学习1.0

疏影月楼台

已于 2023-08-15 14:47:01 修改

阅读量96

点赞数

文章标签： c语言开发语言

于 2023-08-08 16:31:56 首次发布

本文链接：https://blog.csdn.net/weixin_45849140/article/details/132170094

版权

C语言1.0

1、数据类型：内存读取方式、大小不同

char：字符型占用一个字节；-2^7 ---- 2^7-1，用单引号表示

unsigned char:0000 0000 – 1111 1111 0-255

int：整数型占用4个字节;

1111 1111 1111 1111 1111 1111 1111 1111-1000 0000 0000 0000 0000 0000 0000 0001 ；

0000 0000 0000 0000 0000 0000 0000 0000-0111 1111 1111 1111 1111 1111 1111 1111 ；

-2^31-1 ---->-1 ; 0----->2^31-1 一共2^32-1位

其中1000 0000 0000 0000 0000 0000 0000 0000代表-2^31；故int 整型范围为：-2^31 — 2^31-1

unsigned int:0000 0000 0000 0000 0000 00000 0000 0000 - 1111 1111 1111 1111 1111 1111 1111 1111 0-2^32-1

short：短整型占用2个字节

long：长整型占用8个字节

long long：超长整型

float：浮点型

符号位（符号位：指数的正负）指数位数值数值位

1 1 +7 23

if(0.1f + 0.2f == 0.3f)
{
	printf("true\n");
}
else
{
	printf("false\n");
}//此时输出结果为false

0.1用二进制表示为0.00011111……

0.2用二进制表示为0.001100……

0.3用二进制表示为0.01001……

所以无法用==判断两个浮点数是否相等

double：双精度型

符号位符号位：指数的正负指数位数值数值位

1 1+10 52

例如：178.125

先把浮点数分别把整数部分和小数部分转换成2进制
1. 整数部分用除2取余的方法，求得：10110010
2. 小数部分用乘2取整的方法，求得：001
3. 合起来即是：10110010.001
4. 转换成二进制的浮点数，即把小数点移动到整数位只有1，即为：1.0110010001 * 2^111，111是二进制，由于左移了7位，所以是111
把浮点数转换二进制后，这里基本已经可以得出对应3部分的值了
1. 数符：由于浮点数是正数，故为0.(负数为1)
2. 阶码 : 阶码的计算公式：阶数 + 偏移量, 阶码是需要作移码运算，在转换出来的二进制数里，阶数是111(十进制为7)，对于单精度的浮点数，偏移值为01111111(127)[偏移量的计算是：2^(e-1)-1, e为阶码的位数，即为8，因此偏移值是127]，即：111+01111111 = 10000110
3. 尾数：小数点后面的数，即0110010001
4. 最终根据位置填到对位的位置上

注：因为计算机不能识别负号，所以设置最高位作为符号位：0代表正数，1代表负数

sizeof()判断内存大小返回类型sizeof-t为长整型

printf("char : %ld\n",sizeof(char));//一个字节
printf("int : %ld\n",sizeof(int));//4个字节
printf("long : %ld\n",sizeof(long));//8个字节
printf("short : %ld\n",sizeof(short));//2个字节
printf("float : %ld\n",sizeof(float));//4个字节
printf("double : %ld\n",sizeof(double));//8个字节

原码：1：0000 0001 ；-1：1000 0001

反码：除符号位，数值位全部取反

0111 1110 ； 1111 1110

补码：反码+1，正数没有补码；符号位参与计算，不参与取反

1：0000 0001 ；-1：1111 1111

两者相加=0000 0000

2、类型转换

宽转换：从小的数据类型转换到大的数据类型；

#include<stdio.h>
//将char转换成int型
int main()
{
    char a='A';
    int b=a;
    printf("b ：%d\n",b);
    return 0;
}
//输出结果：65
//常见ASII码：48代表0，65代表A，97代表a;

窄转换：从大的数据类型转换到小的数据类型；会存在数据丢失；

#include<stdio.h>
//将int型转换成char型
int main()
{
    int a=-129;
    char b=a;
    printf("b : %d\n",b);
    return 0;
}
//输出结果为-127高位数据丢失:-129--->10……1000 0001转换为char：1000 0001进行转换后为1111 1111结果为-127

3、格式输出

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

int b=128;
printf("b : %d\n",b);

double c=3.1415926;
printf("c : %.7f\n",c);
//当浮点型精度不够时，将float转换double

char *d="HelloWorld";
printf("d : %s\n",d);

4、变量特点

1、变量初始化

定义一个数据要进行初始化，否则会有脏数据残留

2、变量的分类：

（1）、局部变量：作用域在函数体内，函数结束时自动回收

（2）、全局变量：定义在全局，作用在全局，程序开始时创建，结束时回收；任何函数体都能使用，外部定义接口依然可以使用；故全局变量具有不安全性

如果局部变量和全部变量重名，函数中局部变量优先使用。

extern：声明一个变量在其他模块中使用

//主函数体
#include<stdio.h>
#include<test.h>
int b;
void test()
{
    b=15;
}
int main()
{
    b=40;
    testExtern();
    printf("main: b :%d\n",b);
    return 0;
}//此时输出的结果为90

//test.h
void testExtern();

#include<stdio.h>
extern int b;
void testExtern()
{
    printf("b : %d\n",b);
    b=90;
}

（3）、静态变量：static 静态变量只初始化一次，程序就结束时释放，不影响作用域；当static 修饰全局变量，让全局变量只在本文可见；

#include<stdio.h>
void testStatic()
{
    static int a=10;
    a++;
    printf("a : %d\n",a);
}

int main()
{
    testStatic();
	testStatic();
    return 0;
}//输出结果为:11 12因为static没有释放

在全局变量前面加上static，然后测试extern是否依然有用：

#include<stdio.h>
extern int b;
void testextern()
{
    printf(" extern b :%d\n",b);
    b=16;
}

#include<stdio.h>
#include"test.h"
static int b=10;
void test()
{
    int b=14;
    int a=0;
    printf("test: b=%d\n",b);
}
int main()
{
    test();
    b=40;
    testExtern();
    printf("main : b =%d\n",b);
    return 0;

}//运行结果error 因为在extern中无法找到全局变量b;

（4）、const:修饰变量，让变量不可修改；但是在c语言中可以通过指针指向数据的地址从而改变它的值；(指针占8个字节)

define 和const 修饰变量的时机不同；define在预处理阶段已经改变，而const在可执行程序在执行时进行定义和赋值；而且define 修饰的常量值不可更改，但是const定义的常量可以通过指针进行更改。

#include<stdio.h>
int main()
{
    const int a=10;
    int *b=&a;
    *b=20;
    printf("a ： %d\n",a);
    return 0;
}//运行结果为20

（5）、**sizeof()**运算符关键字，计算所占内存大小

5、计算机的内存五大分区

1、栈：存放函数的局部变量；

2、堆：存放用户申请的变量，需要手动释放；

3、静态全局区：存放静态变量全局变量；程序结束由系统自动回收；

.data段：已经初始化的变量

.bss段：未初始化的全局变量

4、文字常量区：存放字符串常量

5、代码段：指令的集合

6、运算符

单目运算符：++、–、~、&、*

双目运算符：+、-、*、/、%、&、|、^ 、=

条件运算符：&& || == != < > <= >=

A&&B 都为真，当A为假时，B不进行运算

A||B 只要一个为真，当A为真的时候，B不进行运算

三目运算符：? :

++自增符 b = a++;相当于 b=a;a=a+1; c = ++a相当于a = a+1; c = a;

#include <stdio.h>
int main()
{
    int a = -1;
    int b = -1;
    int c = 0;
    if (a++ && ++b || c++)
    {
        printf("true\n");
    }
    else
    {
        printf("flase\n");
    }
    printf("a : %d\n", a);
    printf("b : %d\n", b);
    printf("c : %d\n", c);
    return 0;
}//输出结果为false，0，0，1
//++a && ++b || c++ 输出结果为false,0,-1,1
//当a=1,b=1,c=0;运行++a && ++b ||c++ 此时输出结果为true，2 2 0

int i=1,b;
b=(++i)+(i++);//5
b=(i++)+(++i);//4
b=(i++)+(i++);//3
b=(++i)+(++i);//6

7、结构体

struct + 结构体名 {属性，属性……}；

typedef 对已有的类型进行定义；

#include<stdio.h>
struct person
{
	char *name;
	int age;
	int ID;
};
typedef struct person Per;
#define PER struct person

void print_person(struct person per)
{
    printf("name : %s\t age : %d\t ID : %d\n",per.name,per.age,per.ID);
}
int main()
{
    struct person person1;
    person1.name="zhangsan";
    person1.age=20;
    person1.ID=1;
    print_person(person2);
    
    PER Lisi = {"lisi",22,02};
    print_person(Lisi); 
    
    Per person2={"Wangwu",23,03};
    print_person(person2);
    return 0;
}//输出结果name:zhangsan age:20 ID:1
//name:Lisi age:22 ID:2
//name:Wangwu age:23 ID:3

#define文本的替换；处理在预处理阶段，定义时候可能会出现数据的丢失；

typedef：数据类型的替换，处理在最后执行的阶段；

#include<stdio.h>
typedef int *TYPEDEF_POINT;
#define DEFINE_POINT int *
int main()
{
    TYPEDEF_POINT a,b;
    DEFINE_POINT c,d;
    printf("a : %ld\n",sizeof(a));
    printf("b : %ld\n",sizeof(b));
    printf("c : %ld\n",sizeof(c));
    printf("d : %ld\n",sizeof(d));
    return 0;
}//输出结果为 a:8 b:8 c:8 d:4 此时，数据d发生了丢失因为DEFINE_POINT c,d;相当于int *c,d;

结构体嵌套：

#include<stdio.h>
typedef struct Person
{
    char * name;
    int age;
    int ID;
}Per;

void print_Person(Per per)
{
    printf("name: %s age: %d ID: %d",per.name,per.age,per.ID);
}

typedef struct Student 
{
    Per per;
    int score;
    int class;
}Stu;

void print_Student(Stu stu)
{
    print_Person(stu.per);
    printf(" score: %d class: %d\n",stu.score,stu.class);
}
int main()
{
    Stu stu;
    stu.per.name="zhangsan";
    stu.per.age=20;
    stu.per.ID=1234;
    stu.score=100;
    stu.class=203;
    print_Student(stu);

    Stu stu2={{"Lisi",20,1235},100,204};
    print_Student(stu2);
    return 0;
}

结构体的字节对齐：按照数据类型最大的那个类型对齐；结构体嵌套：按照基本数据类型（不包括结构体）最大的那个类型对齐

#include<stdio.h>
struct Size             //struct Size
{						//{
    int a;				//	int a;
    char b;				//	char b[11];
    double c;			//	double c;
};						//};输出结果为size : 24
int main()
{
    printf("Size : %ld\n",sizeof(struct Size));
    return 0;
}//输出结果为size : 16
//尽量将小的数据结构放在一起节省内存

#include<stdio.h>
struct smallSize
{
    int d;
    double c;
};
struct Size
{
    int a;
    struct smallSize size;
    char b;
};
int main()
{
    printf("Size : %ld\n",sizeof(struct Size));
    return 0;
}//输出结果size : 32

8、共用体

多个数据结构共用一块内存

#include<stdio.h>
union data
{
    int a;		//int a;
    char b;		//char b[5];8个字节
};//4个字节
int main()
{
    union data d;
    d.a=65;
    printf("d.b : %c\n",d.b);
    return 0;
}//输出结果d.b : A

大小端模式：

大端模式：高位存在低地址；

小端模式：低位存在低地址；

eg: 0x12345678

大端模式：0x12 0x34 0x56 0x78 ; C51；符合人类查看数据习惯

小端模式：0x78 0x56 0x34 0x12; ARM一般符合计算机计算模式

//判断大小端模式
#include<stdio.h>
union data
{
	int a;
    char b;
}
int main()
{
    union data d;
    d.a=0x12345678;
    if(d.b==0x12)
        printf("big!\n");
    else
        printf("little!\n");
    return 0;
}//输出结果little!

9、枚举体

提高代码的可读性

#include<stdio.h>
enum data
{
    Monday,
    Tuseday,
    Wednesday,
    Thursday,
    Friday,
    Saturday,
    Sunday
};

int main()
{
    enum data d=Monday;
    printf("%d\n",Monday);
    printf("%d\n",Thursday);
    switch(Monday)
    {
        case Monday: 
            printf("Monday!\n");break;
        case Tuseday:
            printf("Tuseday!\n");break;
        case Wednesday:
            printf("Wednesday!\n");break;
        case Thursday:
            printf("Thursday!\n");break;
        case Friday:
            printf("Friday!\n");break;
        case Saturday:
            printf("Saturday!\n");break;
        case Sunday:
            printf("Sunday!\n");break;
    }
    return 0;
}//输出结果0 3 Monday!