Android NDK开发之旅6--C语言--结构体

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 <stdio.h>
#include <stdlib.h>
#include <Windows.h>
#include <string.h>


//结构体是一种构造数据类型
//把不同的数据类型整合起来成为一个自定义的数据类型

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

推荐阅读更多精彩内容