3.结构体(三)

结构体可以简单的理解成Java中的类和Go中的结构体.

使用struct关键字定义。

struct tag {
   member-list
   ...
} variable-list;

• tag是结构体标签。
• member-list是标准的变量定义，比如int i等
• variable-list是结构变量，定义在结构的末尾，最后一个分号之前，你可以指定一个或多个结构变量。

struct Books {
    char title[50];
    char author[50];
    int book_id;
} book;

一般情况下,tag、member-list、variable-list这3部分至少要出现2个。

//此声明声明了拥有3个成员的结构体，分别为整型的a，字符型的b和双精度的c
//同时又声明了结构体变量s1
//这个结构体并没有标明其标签
struct {
    int a;
    char b;
    double c;
} s1;

//此声明声明了拥有3个成员的结构体，分别为整型的a，字符型的b和双精度的c
//结构体的标签被命名为SIMPLE,没有声明变量
struct SIMPLE {
    int a;
    char b;
    double c;
};
//用SIMPLE标签的结构体，另外声明了变量t1、t2、t3
struct SIMPLE t1, t2[20], *t3;

//也可以用typedef创建新类型
typedef struct {
    int a;
    char b;
    double c; 
} Simple2;
//现在可以用Simple2作为类型声明新的结构体变量
Simple2 u1, u2[20], *u3;

在上面的声明中，第一个和第二声明被编译器当作两个完全不同的类型，即使他们的成员列表是一样的，如果令 t3=&s1，则是非法的。

结构体的成员可以包含其他结构体，也可以包含指向自己结构体类型的指针，而通常这种指针的应用是为了实现一些更高级的数据结构如链表和树等。

//此结构体的声明包含了其他的结构体
struct COMPLEX {
    char string[100];
    struct SIMPLE a;
};

//此结构体的声明包含了指向自己类型的指针
struct NODE {
    char string[100];
    struct NODE *next_node;
};

如果两个结构体互相包含，则需要对其中一个结构体进行不完整声明，如下所示：

struct B;    //对结构体B进行不完整声明

//结构体A中包含指向结构体B的指针
struct A {
    struct B *partner;
    //other members;
};

访问结构体成员

#include <stdio.h>
#include <string.h>

struct Books {
   char  title[50];
   char  author[50];
   int   book_id;
};

// 函数声明，必须要声明啊，不然调用不了，报错，这和java不一样
void printBook(struct Books book);

int main( ) {
   struct Books Book1;        /* 声明 Book1，类型为 Books */
   struct Books Book2;        /* 声明 Book2，类型为 Books */

   strcpy(Book1.title, "C Programming");
   strcpy(Book1.author, "Nuha Ali"); 
   Book1.book_id = 6495407;

   strcpy(Book2.title, "Telecom Billing");
   strcpy(Book2.author, "Zara Ali");
   Book2.book_id = 6495700;

   printBook(Book1);
   printBook(Book2);
   return 0;
}

void printBook(struct Books book) {
   printf("Book title : %s\n", book.title);
   printf("Book author : %s\n", book.author);
   printf("Book book_id : %d\n", book.book_id);
}

结构体指针

定义一个指针的基本类型为某种结构体时，该指针变量的值就是结构体变量在内存中的起始地址。
下图所定义的如下结构指针*p指向该结构体变量在内存中的起始地址。

struct student{    
    char name[20];    
    char sex;    
    float score;
} *p;

引用上面定义的结构体对象的成员可以用下面两种方法：

• (*指针名).成员名:.的运算优先级高于*，所以用括号改变其运算顺序
• 指针名->成员名:->被称为指向运算符

例如：(*ptr).name 与 ptr -> name 是等价的。

声明:

struct Books *struct_pointer;
struct_pointer = &Book1;
struct_pointer->title; //为了使用指向该结构体的指针访问结构体成员，必须使用->运算符，这和Go中的.运算符不同。

示例:

#include <stdio.h>
#include <string.h>

struct Books {
    char title[50];
    char author[50];
    int  book_id;
};

void printBook(struct Books *book);

int main() {
    struct Books Book1;    
    struct Books Book2;    

    strcpy( Book1.title, "C Programming");
    strcpy( Book1.author, "Nuha Ali"); 
    Book1.book_id = 6495407;

    strcpy( Book2.title, "Telecom Billing");
    strcpy( Book2.author, "Zara Ali");
    Book2.book_id = 6495700;

    printBook(&Book1);
    printBook(&Book2);
    return 0;
}
void printBook(struct Books *book) {
    printf( "Book title : %s\n", book->title);
    printf( "Book author : %s\n", book->author);
    printf( "Book book_id : %d\n", book->book_id);
}

位域

有些信息在存储时，并不需要占用一个完整的字节，而只需占几个或一个二进制位。
例如在存放一个开关量时，只有0和1两种状态，用1位二进位即可。
为了节省存储空间，并使处理简便，C语言又提供了一种数据结构，称为"位域"或"位段"。

所谓"位域"是把一个字节中的二进位划分为几个不同的区域，并说明每个区域的位数。
每个域有一个域名，允许在程序中按域名进行操作。这样就可以把几个不同的对象用一个字节的二进制位域来表示。

典型的实例：

• 用1位二进位存放一个开关量时，只有0和1两种状态。
• 读取外部文件格式——可以读取非标准的文件格式。例如9位的整数。

位域的定义与结构体的定义类似:

struct 位域结构名 {
    类型说明符 位域名：位域长度
};

例如:

struct bs{
    int a:8;
    int b:2;
    int c:6;
}data;

说明data为bs变量，共占两个字节。其中位域a占8位，位域b占2位，位域c占6位。

对于位域的定义尚有以下几点说明：

• 一个位域必须存储在同一个字节中，不能跨两个字节。如一个字节所剩空间不够存放另一位域时，应从下一单元起存放该位域。也可以有意使某位域从下一单元开始。例如：

struct bs{
    unsigned a:4;
    unsigned  :4;    /* 空域 */
    unsigned b:4;    /* 从下一单元开始存放 */
    unsigned c:4
}

在这个位域定义中，a占第一字节的4位，后4位填0表示不使用,b从第二字节开始，占用4位，c占用4位。

• 由于位域不允许跨两个字节，因此位域的长度不能大于一个字节的长度，也就是说不能超过8位二进位。如果最大长度大于计算机的整数字长，一些编译器可能会允许域的内存重叠，另外一些编译器可能会把大于一个域的部分存储在下一个字中。
• 位域可以是无名位域，这时它只用来作填充或调整位置。无名的位域是不能使用的。例如：

struct k{
    int a:1;
    int  :2;    /* 该2位不能使用 */
    int b:3;
    int c:2;
};

从以上分析可以看出，位域本质上就是一种结构类型，不过其成员是按二进制分配的。

位域的使用

位域的使用和结构体成员的使用相同:

位域变量名.位域名
位域指针变量名->位域名

#include <stdio.h>
#include <string.h>
 struct bs{
    unsigned a:1;
    unsigned b:3;
    unsigned c:4;
} bit,*pbit;

int main(){
    bit.a=1;    /* 给位域赋值（应注意赋值不能超过该位域的允许范围） */
    bit.b=7;    /* 给位域赋值（应注意赋值不能超过该位域的允许范围） */
    bit.c=15;    /* 给位域赋值（应注意赋值不能超过该位域的允许范围） */
    printf("%d,%d,%d\n",bit.a,bit.b,bit.c);    /* 以整型量格式输出三个域的内容 */

    pbit=&bit;    /* 把位域变量 bit 的地址送给指针变量 pbit */
    pbit->a=0;    /* 用指针方式给位域 a 重新赋值，赋为 0 */
    pbit->b&=3;    /* 使用了复合的位运算符 "&="，相当于：pbit->b=pbit->b&3，位域 b 中原有值为 7，与 3 作按位与运算的结果为 3（111&011=011，十进制值为 3） */
    pbit->c|=1;    /* 使用了复合位运算符"|="，相当于：pbit->c=pbit->c|1，其结果为 15 */
    printf("%d,%d,%d\n",pbit->a,pbit->b,pbit->c);    /* 用指针方式输出了这三个域的值 */
}

• 上一篇:2.指针(二)
• 下一篇:4.共用体(四)

• 邮箱 ：charon.chui@gmail.com
• Good Luck!