自定义uipickerview iOS 自定义是什么意思

前言：

自定义数据类型就是用户可以随时在程序中自行定义新的数据类型。自定义数据类型时需要设置数据类型的名称及其成员。数据类型成员各属性的设置方法等同于变量设置时相应属性的设置方法。

导航栏

• 一、结构体

• 1.结构体类型的声明
• 2.匿名结构体类型
• 3.结构体的自引用
• 4.结构体变量的定义与初始化
• 5.结构体内存对齐
• 6.结构体传参
• 7.位段

• 二、枚举
• 三、联合体

• 1.联合体判断大小端
• 2.联合体大小的计算

一、结构体

1.结构体类型的声明

结构是一些值的集合，这些值称为成员变量。结构的每个成员可以是不同类型。

代码如下（示例）：

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
//声明一个结构体类型
//声明一个学生类型，是想通过学生类型，来创建学生变量(对象)，
//描述学生：属性---名字+电话+性别+年龄
struct Stu//结构体关键字---Stu是标签
{
	//成员变量
	char name[20];//名字
	char tele[12];//电话
	char sex[10];//性别
	int age;//年龄
}s4, s5, s6;//结构体全局变量，注意分号
struct Stu s3;//全局变量
int main()
{
	int num;
	//创建的结构体变量
	struct Stu s1;
	struct Stu s2;
	return 0;
}

2.匿名结构体类型

代码如下（示例）：

struct
{
	int a;
	char c;
}sa;
struct
{
	int a;
	char c;
}*psa;//结构体指针
int main()
{
	psa = &sa;//编译器会把以上两个声明当成两个完全不同的两个类型，所以是非法的
	return 0;
}

3.结构体的自引用

在结构中包含一个类型为该结构本身的成员是不行的！

struct Node
{
	int data;//4
	struct Node next;
};

正确的自引用方式：

struct Node
{
	int data;//4
	struct Node* next;//4或8
};

4.结构体变量的定义与初始化

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 };//结构体嵌套初始化

struct T
{
	double weight;
	short age;
};
struct S
{
	char c;
	struct T st;
	int a;
	double d;
	char arr[20];
};
int main()
{
	struct S s = { 'c',{55.6,30},100,3.14,"hello bit" };
	printf("%c %d %lf %s\n", s.c, s.a, s.d, s.arr);
}

5.结构体内存对齐

总的来说就是用空间换时间

结构体在设计时可以改变定义顺序来节省空间

让占用空间小的成员在一起。

//12
struct s1
{
	char c1;
	int i;
	char c2;
};
//8
struct s2
{
	char c1;
	char c2;
	int i;
};

s1的大小为12，s2的大小为8
结构体内存对齐规则：

1. 第一个成员在与结构体变量偏移量为0的地址处。
2. 其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。 对齐数 = 编译器默认的一个对齐数 与 该成员大小的较小值。 VS中默认的值为8
3. 结构体总大小为最大对齐数（每个成员变量都有一个对齐数）的整数倍。
4. 如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。

修改默认对齐数

---

//结构体在设计时可以改变定义顺序来节省空间
//12
#pragma pack(1)//对齐方式不合适可以修改，修改默认对齐数为1
struct s1
{
	char c1;//1 1 1
	int i;  //4 1 1
	char c2;//1 1 1
};
//8
//#pragma pack()//取消设置的默认对齐数，还原为默认
struct s2
{
	char c1;
	char c2;
	int i;
};
int main()
{
	printf("%d\n", sizeof(struct s1));//6
	return 0;
}

6.结构体传参

函数传参的时候，参数需要压栈，会有时间和空间上的系统开销。
如果传递一个结构体对象的时候，结构体过大，参数压栈的系统开销比较大，所以性能下降。
例：

struct S
{
	int data[1000];
	int num;
};
void print1(struct S tmp)
{
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", tmp.data[i]);
	}
	printf("\nnum= %d\n", tmp.num);
}
void print2(const struct S* ps)
{
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", ps->data[i]);
	}
	printf("\nnum=%d\n", ps->num);
}
int main()
{
	struct S s = { {1,2,3,4,5,6,7,8,9,10},100 };
	//print1(s);
	print2(&s);//print2空间更加节省，传递地址效率更高
	return 0;
}

7.位段

结构体实现位段的能力：
位段的声明和结构是类似的，有两个不同

1.位段的成员必须是 int、unsigned int 或signed int char也行（整型家族） 。
2.位段的成员名后边有一个冒号和一个数字。

位段的内存分配

位段的成员可以是 int unsigned int signed int 或者是 char （属于整形家族）类型
位段的空间上是按照需要以4个字节（ int ）或者1个字节（ char ）的方式来开辟的。
位段涉及很多不确定因素，位段是不跨平台的，注重可移植的程序应该避免使用位段。

struct A
{
	int _a : 2;//_a 2个bit位
	int _b : 5;//_b 5个bit位
	int _c : 10;//_c 10个bit位
	int _d : 30;//_d 30个bit位
};
//一定程度节省了空间
int main()
{
	printf("%d\n", sizeof(struct A));
	return 0;
}

二、枚举

枚举顾名思义就是一一列举。
把可能的取值一一列举。
比如我们现实生活中：
周一到周日的枚举；
枚举类型的定义
这些可能取值都是有值的，默认从0开始，一次递增1，当然在定义的时候也可以赋初值。

enum Color
{
	RED=2,//枚举常量
	BLUE=4,
	GREEN=8
};
int main()
{
	//printf("%d\n", RED);//0
	//printf("%d\n", BLUE);//1
	//printf("%d\n", GREEN);//2
	enum Color c = GREEN;
	if (c == GREEN)
	{
		printf("绿色\n");
	}
	return 0;
}

我们可以使用 #define 定义常量，为什么非要使用枚举？
枚举的优点：
1.增加代码的可读性和可维护性
2. 和#define定义的标识符比较枚举有类型检查，更加严谨。
3.防止了命名污染（封装）
4.便于调试
5.使用方便，一次可以定义多个常量、

三、联合体

联合也是一种特殊的自定义类型 这种类型定义的变量也包含一系列的成员，特征是这些成员公用同一块空间（所以联合也叫共用体）。

union Un
{
	char c;
	int i;
};
int main()
{
	union Un u = { 0 };
	//printf("%d\n", sizeof(u));//4
	//这三个地址一样
	printf("%p\n", &u);
	printf("%p\n", &(u.c));
	printf("%p\n", &(u.i));
	return 0;
}

联合的成员是共用同一块内存空间的，这样一个联合变量的大小，至少是最大成员的大小（因为 联合至少得有能力保存最大的那个成员）。

1.联合体判断大小端

int main()
{
	int a = 1;//0x00 00 00 01
	//假设：低------------------------高
	//01 00 00 00 - 小端存储
	//00 00 00 01 - 大端存储
	//
	char* pc = (char*)&a;
	if (*pc == 1)
	{
		printf("小端\n");
	}
	else
	{
		printf("大端\n");
	}
 return 0；
 }

2.联合体大小的计算

联合的大小至少是最大成员的大小。
当最大成员大小不是最大对齐数的整数倍的时候，就要对齐到最大对齐数的整数倍。

union Un1
{
	char c[5];//5 1 8 1
	int i;// 4 8 4
};
union Un2
{
	short c[7];
	int i;
};
int main()
{
	//下面输出的结果是什么？
	printf("%d\n", sizeof(union Un1));//8
	printf("%d\n", sizeof(union Un2));//16
	return 0;
}

最大对齐数是4,但是最大成员大小为5，所以对齐到8

union Un
{
	int a;//4 8 4
	char arr[5];//5 1 8 1
};
int main()
{
	union Un u;
	printf("%d\n", sizeof(u));
	return 0;
}