Android NDK开发之旅 目录
结构体
概念、定义于初始化方式
C 数组允许定义可存储相同类型数据项的变量，结构是 C 编程中另一种用户自定义的可用的数据类型，它允许您存储不同类型的数据项。
结构用于表示一条记录，假设您想要跟踪图书馆中书本的动态，您可能需要跟踪每本书的下列属性：
- Title
- Author
- Subject
- Book ID
定义结构
为了定义结构，您必须使用 struct 语句。struct 语句定义了一个包含多个成员的新的数据类型，struct 语句的格式如下
struct [structure tag]
{
member definition;
member definition;
...
member definition;
} [one or more structure variables];
structure tag 是可选的，每个 member definition 是标准的变量定义，比如 int i; 或者 float f; 或者其他有效的变量定义。在结构定义的末尾，最后一个分号之前，您可以指定一个或多个结构变量，这是可选的。下面是声明 Book 结构的方式：
struct Books
{
char title[50];
char author[50];
char subject[100];
int book_id;
} book;
简单示例
#define _CRT_SECURE_NO_WARNINGS
#include
#include
#include
#include
//结构体是一种构造数据类型
//把不同的数据类型整合起来成为一个自定义的数据类型
struct Man {
//成员
char name[20];
int age;
};
void main() {
//初始化结构体的变量
//第一种方式
struct Man m1 = {"Jack",21};
printf("%s，%d \n", m1.name, m1.age);
//第二种方式
struct Man m2;
m2.age = 23;
//m2.name = "rose"; 不能这样赋值
strcpy(m2.name, "rose");
//或者
//sprintf(m2.name, "Jason");
//不能再赋值
//m1 = {};//类似JavaScript字面量赋值，只能在变量声明时赋值
printf("%s，%d", m2.name, m2.age);
getchar();
}
结果输出：
Jack，21
rose，23
结构体可以在定义之后跟着声明或者初始化变量
struct Man {
char name[20];
int age;
}m1, m2 = {"Lucy",35}; //m1结构体变量名
void main() {
strcpy(m1.name,"Jack");
m1.age = 10;
printf("%s，%d \n", m1.name, m1.age);
printf("%s，%d \n", m2.name, m2.age);
getchar();
}
结果输出：
Jack，10
Lucy，35
匿名结构体
控制结构体变量的个数（限量版），相当于单例
struct {
char name[20];
int age;
}m1;
结构体嵌套
struct Teacher
{
char name[20];
};
struct Student
{
char name[20];
int age;
struct Teacher t;
};
void main() {
//字面量的方式
struct Student s1 = { "jack" ,21,{"Jeason"} };
printf("%s，%d, %s\n", s1.name, s1.age, s1.t.name);
system("pause");
}
结果输出：
jack，21, Jeason
结构体与指针
struct Man
{
char name[20];
int age;
};
void main() {
struct Man m1 = { "Jack",30 };
//结构体指针
struct Man *p = &m1;
printf(" %s, %d\n", m1.name, m1.age);
printf(" %s, %d\n",(*p).name,(*p).age);
//"->"箭头是"(*P)."的简写
printf(" %s, %d\n", p->name, p->age);
system("pause");
}
结果输出：
Jack, 30
Jack, 30
Jack, 30
指针与结构体数组
struct Man
{
char name[20];
int age;
};
void main() {
struct Man mans[] = { {"Jack",20},{"Rose",19} };
//遍历数组
//第一种方式
struct Man *p = mans;
for (; p < mans + 2;p++) {
printf("%s, %d\n", p->name, p->age);
}
//第二种方式
int i = 0;
for (; i < sizeof(mans)/sizeof(struct Man); i++)
{
printf("%s, %d\n", mans[i].name, mans[i].age);
}
system("pause");
}
结果输出：
Jack, 20
Rose, 19
Jack, 20
Rose, 19
结构体的大小
字节对齐，结构体变量的大小，必须是最宽基本数据类型的整数倍。通过空间换取时间来提升读取效率。
宽基本数据类型的整数倍的意义：提升读取的效率。
struct Man {
int age;
double weight;
};
void main() {
struct Man m1 = { 20 ,89.9 };
printf(" %#x , %d\n", &m1, sizeof(m1));
getchar();
}
结果输出：
0x95fd40 , 16
本示例中 字节最长的基本数据类型为 double 8 位 * 2（成员数量） = 16
结构体与动态内存分配
void main() {
struct Man *m_p = ( struct Man* )malloc(sizeof(struct Man) * 10);
struct Man *p = m_p;
//赋值
p->name = "Jack";
p->age = 20;
p++;
p->name = "Rose";
p->age = 20;
struct Man *loop_p = m_p;
for (; loop_p < m_p + 2;loop_p++) {
printf("%s ,%d\n", loop_p->name, loop_p->age);
}
free(m_p);
m_p = NULL;
getchar();
}
结果输出：
Jack ,20
Rose ,20
typedef取别名，定义新的类型，方便使用
typedef 类型取别名
用途一：
定义一种类型的别名，而不只是简单的宏替换。可以用作同时声明指针型的多个对象。比如：
char* pa, pb; // 这多数不符合我们的意图，它只声明了一个指向字符变量的指针，和一个字符变量；
以下则可行：
typedef char* PCHAR;
PCHAR pa, pb;
这种用法很有用，特别是char* pa, pb的定义，初学者往往认为是定义了两个字符型指针，其实不是，而用typedef char* PCHAR就不会出现这样的问题，减少了错误的发生。
用途二：
用typedef来定义与平台无关的类型。
比如定义一个叫 REAL 的浮点类型，在目标平台一上，让它表示最高精度的类型为：
typedef long double REAL;
在不支持 long double 的平台二上，改为：
typedef double REAL;
在连 double 都不支持的平台三上，改为：
typedef float REAL;
也就是说，当跨平台时，只要改下 typedef 本身就行，不用对其他源码做任何修改。
标准库就广泛使用了这个技巧，比如size_t。另外，因为typedef是定义了一种类型的新别名，不是简单的字符串替换，所以它比宏来得稳健。
这个优点在我们写代码的过程中可以减少不少代码量哦！
用途三：
为复杂的声明定义一个新的简单的别名。方法是：在原来的声明里逐步用别名替换一部分复杂声明，如此循环，把带变量名的部分留到最后替换，得到的就是原声明的最简化版。
简单示例
//Age int 类型的别名
typedef int age;
//Age int指针类型的别名
typedef int* Ap;
//写法一
struct Man
{
char name[20];
int age;
};
typedef struct Man JavaMan;
typedef struct Man* JM;
//----------------------------------------
//写法二
//结构体取别名
typedef struct Woman {
char name[20];
int age;
}W,*WP; //W 是Woman结构体的别名， WP 是Woman结构体指针的别名
//typedef struct Woman W;
//typedef struct Woman* WP;
void main() {
int i = 5;
Ap p = &i;
JavaMan m1 = { "Jack", 25 };
JM jm1 = &m1;
printf("%s, %d\n", m1.name, m1.age);
printf("%s, %d\n", jm1->name, jm1->age);
//结构体变量
W w1 = { "Rose",20 };
//结构体指针
WP wp1 = &w1;
printf("%s, %d\n", w1.name, w1.age);
printf("%s, %d\n", wp1->name, wp1->age);
getchar();
}
结果输出：
Jack, 25
Jack, 25
Rose, 20
Rose, 20
结构体函数指针成员
struct Girl {
char *name;
int age;
//函数指针
void(*sayHi)(char*);
};
void sayHi(char * text) {
MessageBox(0,text, "title", 0);
}
//Girl 结构体类似于Java中类，name和age类似于属性，sayHi类似于方法;
void main() {
struct Girl g1;
g1.name = "Lucy";
g1.age = 18;
g1.sayHi = sayHi;
g1.sayHi("HELLO");
getchar();
}
结果输出：
弹出一个窗口
别名结构体原本的名字相同时,struct Girl g1 可以简写为Girl g1 (类似于OOP思想)
//定义一个Girl结构体，包括属性和方法
typedef struct Girl {
char *name;
int age;
//函数指针
void(*sayHi)(char*);
}Girl;//给结构体取一个别名Girl（别名可以与结构体原本的名字相同）
//Girl结构体指针取别名GirlP
typedef Girl* GirlP;
//结构体的成员函数
void sayHi(char* text) {
MessageBoxA(0, text, "title", 0);
}
//自定义的一个函数
void reName(GirlP gp1) {
gp1->name = "Jack";
gp1->age = 23;
}
void main() {
Girl g1 = { "Lucy", 18, sayHi };
printf("%s, %d\n", g1.name, g1.age);
GirlP gp1 = &g1;
//传递指针，改名（只有传递指针才能修改值，所以指针是比较常用的方式）
reName(gp1);
printf("%s, %d\n", g1.name, g1.age);
gp1->sayHi("Byebye!");
getchar();
}
结果输出：
Lucy, 18
Jack, 23
同时弹出一个窗口
微信号kpioneer