内存操作函数
memcpy
void* memcpy (void* destination , const void* source , size_t num)
- 函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置
- 这个函数在遇到 ‘\0’ 的时候并不会停下来,按照字节一个一个的拷贝过去。
- 如果source和destination有任何的重叠,复制结果都是未定义的
- 返回值支持连续拷贝memcpy (a , ( memcpy ( b , c , 10 ) , 10 )
- memcpy的模拟实现
#include<stdio.h>
void* my_memcpy(void* dst, const void* src, size_t num)
{
char* ch_dst = (char*)dst;
char* ch_src = (char*)src;
for (int i = 0; i < num; ++i)
{
ch_dst[i] = ch_src[i];
}
return dst;
}
int main()
{
char a[] = "abcdefghijk ";
char b[11];
my_memcpy(b, a, 11);
for (int i = 0; i < 11; ++i)
{
printf("%c", b[i]);
}
return 0;
}
memove
void* memove( void* destination , const void* source , size_t num)
- 和memcpy的差别就是memove函数处理的原内存块和目标内存块是可以重叠的。
- 如果原空间和目标空间出现重叠,就得使用memove函数处理。
- 这里的重叠会出现两种情况前重叠和后重叠
- memove的模拟实现
#include<stdio.h>
void* my_memmove(void* dst, const void* src, size_t num)
{
char* ch_dst = (char*) dst;
const char* ch_src = (const char*)src;
if (ch_dst >= ch_src&&ch_dst <= ch_src + num)
{
for (int i = num-1; i >=0; --i)
ch_dst[i] = ch_src[i];
}
if (ch_dst +num>= ch_src&&ch_dst+num <= ch_src + num)
{
for (int i = 0; i < num; ++i)
ch_dst[i] = ch_src[i];
}
return dst;
}
int main()
{
int a3[9] = {
1, 2, 3, 4, 5 };//这里的数组空间一定要满足拷贝后所需要空间大小
my_memmove(a3 + 4, a3, 20);
return 0;
}
memset
void* memset(viod* ptr,int value , size_t num);
- 将每一个字节初始化
- 但是存在局限性
#include<stdio.h>
#include<string.h>
int main()
{
int a[10];
memset(a, 0, sizeof(a));//将每一个字节初始化为0
//存在局限性,防止误用
memset(a, 1, sizeof(a));
//这样初始化就是将整型的每一个字节初始化为1,就变成了00000001 00000001 00000001 00000001(16843009)
return 0;
}
结构体
结构体类型的声明
- 结构是一些值的集合,这些值称为成员变量。结构的每一个成员可以是不同类型的变量
- 结构体在声明时没有开空间,定义之后才会开空间
- 访问结构体成员时可以使用 -> 或 .
- 例如描述一个学生时
struct Stu
{
char name[20];
int age;
char sex[5];
char id[20];
};
- 在声明的时候,可以不完全声明,结构体在声明的时候可以省略掉结构体标签,比如:
//匿名结构体类型
struct
{
int a;
char b;
float c;
}x;
struct
{
int a;
char b;
float c;
}a[20],*p;//结构体变量,这里的变量是全局变量,但是并不推荐这样写。
typedef struct Teacher
{
// 结构体的成员
char name[30];
int age;
char addr[100];
int tel;
}Tea, T, *PT;
//Tea,T是typedef出来的struct Teacher 类型;*PT是typedef出来的指针
//等价于typedef struct Teacher Tea;
//等价于typedef struct Teacher* Pt;
注意:编译器会把以上两个结构体当成完全不同的两个类型,所以p=&x是非法的。
结构体的自引用
- 在结构体中可以包含一个类型为该结构本身的成员
struct Node
{
int val;
struct Node next;//这里是非法定义,这样会存在无数多个结构体
}
struct Node
{
int val;
struct Node* next;//应该定义为指针形式
}
结构体的定义和初始化
有了结构体类型,就可以定义变量
struct Point
{
int x;
int y;
}p1;//声明类型的同时定义变量p1
struct Point p2;//定义结构体变量p2
struct Point p3={
x,y};//初始化:定义变量的同时赋初值
struct Stu //类型声明
{
char name[15];//名字
int age; //年龄
};
struct Stu s={
"zhangsan",20};//初始化
struct Node
{
int data;
struct Point p;
struct Node* next;
}n1={
10,{
4,5},NULL};//结构体嵌套初始化
struct Node n2={
20,{
5,6},NULL};//结构体嵌套初始化
结构体内存对齐
首先我们需要掌握结构体对齐规则:
-
第一个成员与结构体变量偏移量为0的地址处。
-
其他成员变量要对齐到某个数字(对其数)的整数倍的地址处。
对其数 = 编译器默认的一个对其数 与 该成员大小的较小值。 -
vs中默认的值为8
-
结构体总大小为最大对其数(每个成员变量都有一个对其数)的整数倍。
-
如果嵌套了结构体的情况,嵌套的结构体对齐到自己的最大对其数的整数倍,结构体的整体大小就是所有最大对其数(含嵌套结构体的对其数)的整数倍。
那么为什么存在内存对齐呢?
- 平台原因(移植原因):不是所有的硬件平台都能访问任意地址上的任意数据的;某些硬件平台只能在某些地址处取某些特定类型的数据,否则抛出硬件异常。
- 性能原因:数据结构(尤其是栈)应该尽可能地在自然边界上对齐。原因在于,为了访问未对齐的内存,处理器需要做两次内存访问;而对齐的内存访问仅需要一次访问。
总体来说:
结构体的内存对齐是拿空间换取时间的做法。
那么在设计结构体的时候,既要满足对齐,又要节省空间,那么我们就要占用空间小的成员尽量集中在一起。下面有两个例子:
struct s1
{
char c1;
int i;
char c2;//所占内存为12个字节
};
struct s2
{
char c1;
char c2;
int i;//所占内存为8个字节
};
虽然s2于s1类型的成员一模一样,但是他们所占空间的大小有一些区别
修改默认对齐数
#include<stdio.h>
#pragma pack(8)//设置默认对齐数为8
struct s1
{
char c1;//1个字节(占位0)
int i;//4个字节(占位4,5,6,7)
char c2;//一个字节(占位8)
//所以所占空间为9个字节,但是结构体总大小为最大对齐数(每个成员变量都有一个对齐数)的整数倍
};
#pragma pack()//取消设置的默认对其数,还原为默认
int main()
{
printf("%d\n",sizeof(struct s1));//输出结果为12
return 0;
}
对齐方式不合适的时候,我们可以自己更改默认对其数
结构体传参
函数传参的时候,参数需要压栈,会有时间和空间上的系统开销。
如果传递一个结构体对象的时候,结构体过大,参数压栈的系统开销比较大,所以会导致性能的下降。
所以,结构体传参的时候,要传结构体的地址。
struct S
{
int data[1000];
int num;
};
struct S s={
{
1,2,3,4},1000};
void print1(struct S*ps)
{
printf("%d\n",ps->num);
}
int main()
{
print1(&s);
return 0;
}
位段
位段的声明和结构体是类似的,但是存在两个不同:
- 位段成员必须是int、unsigned int 或 signed int 。
- 位段的成员名后边有一个冒号和一个数字。比如:
struct A
{
int _a:2;
int _b:5;
int _c:10;
int _d:30;
};//这里的A就是一个位段
那么位段A的大小是多少呢?
位段的内存分配
- 位段的成员可以是int unsigned int signed int 或是 char (属于整型家族)类型
- 位段的空间上是按照需要以4个字节( int )或者1个字节(char)的方式来开辟的。
- 位段涉及很多不确定的因素,位段是不跨平台的,注重可移植的程序应该避免使用位段。
- 下面举例说明
位段的跨平台问题
- int位段被当成有符号数还是无符号数是不确定的。
- 位段中最大位的数目不能确定。(16位机器最大16,32位机器最大32,写成27,在16位机器会出问题。
- 位段中的成员在内存中从左向右分配,还是从右向左分配标准尚未定义。
- 当一个结构包含两个位段,第二个位段成员比较大,无法容纳于第一个位段剩余的位时,是舍弃剩余的位还是利用,这是不确的。
总结
跟结构相比,位段可以达到同样的效果,但是可以很好的节省空间,但是有跨平台的问题存在。