来源:黑马程序员
1.%d
或 %i
:用于输出有符号整数(int
)。
2.%u
:用于输出无符号整数(unsigned int
)。
3.%f
:用于输出浮点数(float
或double
)。默认情况下,输出六位小数。
4.%lf
:专门用于输出double
类型的浮点数(尽管%f
也可以,但%lf
更明确)。
5.%c
:用于输出单个字符(char
)。
6.%s
:用于输出字符串(char
数组)。
7.%x
或 %X
:用于输出无符号整数(unsigned int
)的十六进制形式,%x
使用小写字母,%X
使用大写字母。
8.%o
:用于输出无符号整数(unsigned int
)的八进制形式。
9.%%
:输出一个%
字符。
10.%p
:用于输出指针的值,以十六进制形式表示。
11.%zu:
专门用于输出size_t
类型的无符号整数值。
引入共同体的原因是一种数据可能有多种类型。
语法:
union [共同体名称]{
};
示例:
union MoneyType {
int moneyi;
double moneyd;
char moneystr[100];
};
注意每个类型的共同体成员不能重名,并且每次只能赋一个值!
C语言给字符串型变量进行赋值建议用strcpy函数,函数原型如下:
char *strcpy(char *dest, const char *src);
变量介绍:
dest
是指向用于存储复制内容的目标数组(字符串)的指针。
src
是指向要复制的源字符串的指针。
函数返回目标字符串的指针。
我这里用的visual studio推荐用strcpy_s,中间需要加一个参数代表原字符串型变量的大小。
参考代码:
#include <stdio.h>
#include <string.h>
typedef union{
int moneyi;
double moneyd;
char moneystr[100];
} MoneyType;
int main()
{
MoneyType money;
//money.moneyi = 100;
//money.moneyd = 99.5;
strcpy_s(money.moneystr,sizeof(money.moneystr),"100万");
//printf("%d\n",money.moneyi);
//printf("%lf\n", money.moneyd);
printf("%s\n", money.moneystr);
return 0;
}
共用体的特点:
● 共用体,也叫联合体,共同体
● 所有的变量都使用同一个内存空间
● 所占的内存大小=最大成员的长度(也受内存对齐影响,总大小也一定是最大成员的整数倍)
● 每次只能给一个变量进行赋值,因为第二次赋值时会覆盖原有的数据
在上一讲的基础上运行下面的代码
printf("%p\n",&(money.moneyi));
printf("%p\n",&(money.moneyd));
printf("%p\n",&(money.moneystr));
运行结果:
得证所有的变量都使用同一个内存空间。
那么上一讲的money到底占用多少内存呢?
printf("%zu",sizeof(money));
输出结果:
原因是char moneystr[100]并不能视为最大长度的成员,它是100个char类型的变量组成的数组。最大长度成员是double,也就是说这个联合体的大小不仅得大于100,而且得是8的倍数。100不起字节,加4刚好是8的倍数。
使用场景:
结构体:一个事物包含多种属性
联合体:一个属性有多种类型
存储方式:
结构体:各存各的
共用体:存一起,多次存会覆盖
内存占用:
结构体:各个变量的总和(受内存对齐影响)
共用体:最大类型(受内存对齐影响)
注意:这四个函数需要#include <stdlib.h>才能使用。
malloc函数适合用来申请连续的空间,函数原型如下所示:
void* malloc(size_t size);
通过 malloc
,程序可以在堆区(heap)动态地请求分配指定大小的内存块,并在分配成功后返回一个指向该内存块的指针。如果分配失败(例如,由于内存不足),malloc
会返回 NULL
指针。
参数size
指定了要分配的内存大小,单位是字节(byte)。
由于数组是占用一段连续内存空间的数据结构,所以我们可以直接用数组来操作这一段内存空间。
举例:
int *p=malloc(10 * sizeof(int));
指针p指向的连续内存可以存储10个int类型数据,这时候可以直接给p[0]到p[9]赋值。
p[0]=100;
总体示例:
#include <stdio.h>
#include <stdlib.h>
int main()
{
//开辟一片能存储100个int类型整数的连续内存空间
int *p=malloc(10 * sizeof(int));
printf("%p\n",p);
for (int i = 0; i < 10; i++)
{
//赋值方法1 指针步进
//*(p + 1) = (i + 1) * 10;
//赋值方法2 遍历数组
p[i]= (i + 1) * 10;
}
for (int i = 0; i < 10; i++)
{
printf("%d ",p[i]);
}
return 0;
}
函数原型:
void *calloc(size_t num, size_t size);
参数:①num 要分配的元素数量
②size 每个元素的大小
返回值:成功时,返回一个指向分配的内存的指针。这块内存的大小至少是 num * size
字节,并且所有位都被初始化为零。如果分配失败(例如,因为内存不足),则返回 NULL
指针。
重点掌握malloc函数,效率更高;calloc的初始化就是默认赋值为0作用不大。
函数原型:
void* realloc( void* _Block, size_t _Size);
参数:①通用指针_Block 指向想要修改的内存块的指针
②size 想要扩充的字节大小
realloc可以扩容内存并且保存原来的数据,但是新开辟的空间里面存储的是乱码
#include <stdio.h>
#include <stdlib.h>
int main()
{
int* p = calloc(10,sizeof(int));
for (int j = 0; j < 10; j++) {
p[j] = j * 10+1;
printf("%d ",p[j]);
}
printf("\n");
int *pp=realloc(p,20*sizeof(int));
for (int i = 0; i < 20; i++) {
printf("%d ", p[i]);
}
return 0;
}
运行结果:
另外最好不要用这个函数,影响代码安全性。上次windows蓝屏不就是因为微软新来了一个小孩,他的野指针在天上飞么?(bushi
函数原型:
void free(void* _Block);
不用了的内存空间最好随手释放,填入你想要释放的内存块的地址。
动态内存分配的小细节:
1,malloc创建空间的单位是字节
因此malloc(100)之后能存储25个int类型数据,50个short型数据。
2,malloc返回的是void类型的指针,没有步长的概念,也无法获取空间中的数据,需要强转
malloc返回类型是void*,void *p无法进行*(p+1)这样的操作,正确做法:
int *p=(int *)malloc(100);
*(p + 1) = 10;
当然也可以强转成其他返回类型
3,malloc返回的仅仅是首地址,没有总大小,最好定义一个变量记录总大小
上文的int*规定了指针步长,p指针指向了内存的首地址,所以开辟一个100字节的内存可以存储25个int类型。
#include <stdio.h>
#include <stdlib.h>
#define length 25
int main()
{
int* p = (int*)malloc(length * sizeof(int));
for (int i = 0; i < length; i++) {
p[i] = i * 4 + 7;
}
printPoint(p,length);
return 0;
}
int printPoint(int* point, int len)
{
for (int i = 0; i < len; i++) {
printf("%d ",point[i]);
}
printf("\n");
}
4,malloc申请的空间不会自动消失,如果不能正确释放,会导致内存泄露
5,malloc申请的空间过多,会产生虚拟内存
当申请的空间过多,因为每一个内存空间不会在刚申请的时候就立马使用,所以c语言并不会立马就在内存中去开辟空间,而是什么时候存储数据了,才会真正的分配空间
目的:为了提高内存的使用效率
6,malloc申请的空间没有初始化值,需要先赋值才能使用
7,free释放完空间之后,空间中数据叫做脏数据,可能被清空,可能被修改为其他值
8,calloc就是在malloc的基础上多一个初始化的动作
9,realloc修改之后的空间,地址值有可能发生变化,也有可能不会改变,但是原本的数据不会丢失
10,realloc修改之后,无需释放原来的空间,函数底层会进行处理