C语言规定，在程序中使用的每一个数据都必须指定其数据类型。声明变量的时候需要指明数据类型，声明函数的时候也需要指明函数的返回值数据类型。
C语言的数据类型分为：基本类型、构造类型，指针类型，空类型。
基本类型又分为：字符类型(char)，整型(int、short、long)，实型(float、double)，枚举类型(enum)
构造类型又为分：数组，结构体(struct)，共用体(union)
不同的数据类型点用的内存空间是不同的，可以用sizeof运算符来计算出各种数据类型占内存的大小，单位是字节
一、基本类型
基本类型分为:字符类型(char)，整型(short,int,long)，实型(float,double)，枚举类型(enum)
字符、整型又分为有符号和无符号，无符号要用关键字unsigned标识,它们的取值是有大小限制的
'a','1','(等这些都属于字符类型，这些字符是以对应ASCII码的值存在内存中的，本质上字符类型就是一个1个字节大小的整型。char取值范围:-128到127(-2^7~2^7-1)
short取值范围:-32768到32767(-2^15~2^15-1)
int取值范围:-2147483648到2147483647(-2^31~2^31-1)
long取值范围:-2147483648到2147483647(-2^31~2^31-1)
unsigned char取值范围:0到255(0~2^8-1)
unsigned short取值范围:0到65535(0~2^16-1)
unsigned int取值范围:0到4294967295(0~2^32-1)
unsigned long取值范围:0到4294967295(0~2^32-1)
注意C语言是没有字符串类型的，在C语言中是用字符数组来表示字符串的,比如：char a[]="hello world"或char a[20]="hello world"，但不能char a[20];a="hello world"
枚举类型基本格式为：
enum 枚举类型名 { 枚举常量1[=整型常数],枚举常量2[=整型常数],.....};
"[=整型常数]"是给枚举常量赋值的，是可以省略的。如果不赋初值，编译器会为每一个枚举常量赋一个不同的整型值，从第一个0，第二个1等，依次加1给每一个成员。
比如：enum Week { 星期一, 星期二, 星期三, 星期四, 星期五, 星期六, 星期日 };
#include <stdio.h>
enum Week { 星期一, 星期二, 星期三, 星期四, 星期五, 星期六, 星期日 };//枚举类型的定义
enum color {Black,White,Red,Blue,Green,Brown};
void main()
{
printf("%d\n", sizeof(char));//char占1个字节，a,b,c
printf("%d\n", sizeof(short));//short占2个字节
printf("%d\n", sizeof(unsigned short));//无符号short占2个字节
printf("%d\n", sizeof(int));//int占4个字节
printf("%d\n", sizeof(long));//long占4个字节
printf("%d\n", sizeof(float));//float占4个字节
printf("%d\n", sizeof(double));//double占8个字节
enum color c1 = Green;
printf("Green is %d\n", c1);//输出Green is 4，
char a = '(';//字符
//整型
int b = 10;
short c = -1;
long d = 12345;
unsigned int e= 123;
//浮点型
float fb = 3.14f;//f可有可无
double g = 3.14;
printf("%f\n", fb);
printf("%lf\n", g);
getchar();
}
二、构造类型
1.数组
数组是具有相同类型的一组有序数据的集合，数组在内存中占用一段连续的存储空间
#include <stdio.h>
#define N 5
void main()
{
//数组的定义，数组在内存是连续排列的,[]里的数字表示元素的个数，[]有多少个就表示多少维数组
//一维数组
int a[5] = {1,2,3,4,5};
int c[] = { 1,2,3,4,5 };
int b[5];
b[0] = 0;//初始化,数组的下标是从0开始的
b[1] = 1;
b[2] = 2;
b[3] = 4;
b[4] = 6;
/*可以用for循环语句来初始化数组
for (int i = 0;i < 5;i++)
{
b[i] = i;
}
*/
/*
int n = 5;
int d[n];
定义数组时的[]里的元素个数不能用变量，只能用常量
*/
int d[N];//N是一个常量，所以是可以的
int e[5] = { 0 };//数组全部元素初始化为0
int f[5] = {1,2,3};//只是前3个元素初始化，后面的元素自动初始化为0
printf("%d\n", sizeof(a));//求内存占多少,输出20，元素的个数*数据类型占内存的大小
printf("%d\n", sizeof(a) / sizeof(int));//求数组多少个元素，输出5
//输出数组元素,数组的下标是从0开始的，下标可以用常量，也可以用变量，也可以用表达式
for (int i = 0;i < 5;i++)
{
printf("%d\n", a[i]);
}
for (int i = 0;i < 5;i++)
{
printf("%d\n", b[i]);
}
//二维数组,二维数组可以当作一个一维数组，每一个元素又是一个一维数组，可以把它看作m行n列。二维数组和多维数组其实就是一个特殊的一维数组
int a1[3][4] = {1,2,3,4,5,6,7,8,9,10,11,12};//也可以int a1[3][4]={{1,2,3,4},{5,6,7,8},{9,10,11,12}}
for (int i = 0;i < 3;i++)//显示二维数级组
{
for (int j = 0;j < 4;j++)
{
printf("%-6d", a1[i][j]);
}
printf("\n");
}
for (int i = 0;i < 12;i++)
{
printf("%-6d", a1[i / 4][i % 4]);//可以用a1[i / 4][i % 4]读出二维数组的全部元素
}
printf("\n");
//二维数组前面一个[]里的数字在初始化时是可以省略的。多维数组初始化时只有第一个[]里的数字能省略
int a2[][4] = { {1,2,3,4} };//这样也是可以的
/*
int a3[3][] = { {0},{0},{0} }这样是不可以的
int a4[][4];只是声明是不可以省略第一个[]里的数字
int a5[3][4]={{1},{2},{3}}和int a5[3][4]={{1,0,0,0},{2,0,0,0},{3,0,0,0}}是一样的
全部初始化为0与一维数组是一样的
int a6[3][4]={0};
*/
/*
二维数组地址的引用
元素a[i][j]的地址是&a[i][j],也是a[i]+j，&a[i][j]等价于a[i]+j。二维数组的数组名代表该数组的首地址，比如a代表&a[0][0]
二维数组每一行的首地址为a[0],每二行的首地址为a[1],......，第n行的首地址为a[n-1]
二维数组元素的引用
数组名[行下标表达式][列下标表达式]，如a[0][0]、a[i][j],a[i][j]与*(&a[i][j])与*(a[i]+j)等价
*/
getchar();
}2.结构体
结构体是一种构造数据类型，用来把不同类型的数据组合成一个整体。
结构体类型定义：
struct [结构体名]
{
类型标识符 成员名;
类型标识符 成员名;
类型标识符 成员名;
......
};
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>
//结构体定义第一钟形式
#define Info1 struct info1//用Info1代替struct info1定义结构体
Info1//结构体定义，定义结构体类型。这里没有分配内存
{
char phone[20];//字符串，其实就是一个数组
char name[10];
char sex[3];//字符
int age;//整型
float score;//浮点型
};
Info1 myinfo4, myinfo5;//结构体变量
//结构体定义第二钟形式
struct info//结构体定义，定义结构体类型。这里没有分配内存
{
char phone[20];//字符串，其实就是一个数组
char name[10];
char sex[3];//字符
int age;//整型
//int age=2;//不能直接赋值
float score;//浮点型
};
struct info myinfo1, myinfo2, myinfo3;//创建三个结构体变量
//结构体定义第三钟形式
struct info2//结构体定义，定义结构体类型。这里没有分配内存
{
char phone[20];//字符串，其实就是一个数组
char name[10];
char sex[3];//字符
int age;//整型
float score;//浮点型
int info2;//成员名可以和类型名相同
} myinfo6={"13525483578", "小强", "男", 18, 80,2 },myinfo7,myinfo8;//myinfo6,myinfo7,myinfo8结构体变量,可以直接在这里初始化，也可以不初始化
struct//无名结构体
{
char phone[20];//字符串，其实就是一个数组
char name[10];
char sex[3];//字符
int age;//整型
float score;//浮点型
} myinfo9 = { "13525483578", "小红", "女", 18, 80 }, myinfo10, myinfo11;//无名结构体变量是有限的,只能在这里声明定义变量
//结构体嵌套
struct MyAllInfo
{
int data;
char remark[200];
struct info info1;
};
/*
struct是关键字，不可以省略。info是结构体名，是可以省略的，省略后叫做无名结构体
struct info是结构体类型，不分配内存，不能赋值、存取、运算。
结构体是可以嵌套定义
定义结构体时计算机还没有为它分配内存，只有在创建一个结构变量后才会分配内存的,分配的长度大于等于所有成员变量所占字节数之和。
不能直接在定义结构体时给里面的成员变量赋值
无名结构体也叫匿名结构体，就是不指定结构体的名称，但一定要在结构体定义的同时声明至少一个结构体变量，否则是没有意义的，是不能在以后程序中声明这钟类型的变量
*/
void main()
{
//结构体初始化第一种形式，就是一个个成员赋值
struct info myinfo;//创建一个变量，struct info是一个整体，不可省略struct
myinfo.age = 20;//myinfo.age这样来访问内部成员
myinfo6.age = 18;
int age = 19;//结构体成员名和程序中的变量名是可以相同的
//myinfo.name = "name";//字符串是不能这样直接赋值的。
//初始化字符串要用sprintf或strcpy,要使用这两个函数要关闭安全检查#define _CRT_SECURE_NO_WARNINGS，strcpy要把string.h包含进来才能用
sprintf(myinfo.name, "小明");
printf("姓名：%s\n", myinfo.name);
strcpy(myinfo.phone, "13525483578");
printf("电话：%s\n", myinfo.phone);
myinfo7 = myinfo6;//结构体变量可以直接赋值结另外一个结构体变量，不过要相同类型才行,整体赋值时里面的字符串也能直接赋值
printf("姓名：%s\n", myinfo7.name);
/*
myinfo = { "13525483578","小明" ,"男",18,80 }
这样是不行的，结构体变量用大括号赋值,只能在创建并初始化才可以
*/
//结构体初始化第二种形式
struct info myinfomation = {"13525483578","小明" ,"男",18,80};
printf("我的姓名是%s\n", myinfomation.name);
//结构体初始化第三种形式，像上面结构体定义第三钟形式里的那样,直接初始化
printf("我的姓名是%s\n", myinfo6.name);
//无名结构体
printf("我的姓名是%s\n", myinfo9.name);
//嵌套
struct MyAllInfo allinfo;
allinfo.data = 100;
sprintf(allinfo.remark, "I am a student");
allinfo.info1.age = 22;//给嵌套的结构体变量的成员赋值
printf("%d,%d\n", allinfo.data, allinfo.info1.age);
//结构体数组，结构体数组的定义跟结构体的定义是一样的，只不过声明变量时是用数组而已。初始化跟数组一样
struct info arrinfo[3] = { {"13525483578","小明" ,"男",18,80},{ "13525483575", "小强", "男", 20, 80 },{ "13625483578", "小红", "女", 18, 90 } };
for (int i = 0;i < 3;i++)
{
printf("姓名：%s,性别：%s,年龄：%d,电话：%s,分数：%.1f\n", arrinfo[i].name, arrinfo[i].sex, arrinfo[i].age, arrinfo[i].phone, arrinfo[i].score);
}
getchar();
}3.共用体
共用体的用途：使几个不同类型的变量共占一段内存（相互覆盖）
共用体的定义、初始化和引用都和结构体类似，只不过关键把struck换成union，也不能在定义共用体变量时初始化。
用大括号初始化时，只能初始化第一个。
共用体变量任何时刻只有一个最后成员存在，它分配内存长度>=最长成员所占字节数，它分配内存长度要能整除最小成员的字节数。
比如：最大成员所占字节数是9，最小成员所占字节数是2，那么这个共用体所占内存长度不是9，而是10，因为还要被2整除。
共用体变量可以直接赋值给另外一个共用体变量。
共用体定义：
union [共用体名]
{
类型标识符 成员名;
类型标识符 成员名;
类型标识符 成员名;
......
};
union[共用体名] a, b;
union [共用体名]
{
类型标识符 成员名;
类型标识符 成员名;
类型标识符 成员名;
......
}a,b;不能在这里对变量初始化，这个跟结构体不同
union
{
类型标识符 成员名;
类型标识符 成员名;
类型标识符 成员名;
......
}a, b;
三、指针类型（在后面单独学习）
四、空类型(void)
void类型表示为空类型，不是空的意思，而是代表任意类型。
一般用在指针和函数里，用在指针里叫空指针，又叫万能指针，就是未知类型的指针。
用在函数前面时表示无返回值，作为参数时表示无参数。
扫一扫
3625
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
