学习C语言第十五天

第一项

C 字符串

字符串实际上是使用空字符 \0 结尾的一维字符数组，\0 是用于标记字符串的结束。

空字符（Null character）又称结束符，缩写 NUL，是一个数值为 0 的控制字符，\0 是转义字符，意思是告诉编译器，这不是字符 0，而是空字符。

以下是 C/C++ 中定义的字符串的内存表示：

不需要把 null 字符放在字符串常量的末尾。在初始化数组时，自动把 \0 放在字符串的末尾。

eg：

#include
 
int main ()
{
   char site[7] = {'R', 'U', 'N', 'O', 'O', 'B', '\0'};
 
   printf("ZH_edifier: %s\n", site );
 
   return 0;
}

ZH_edifier: RUNOOB

有大量操作字符串的函数：

序号	函数 & 目的
1	strcpy(s1, s2); 复制字符串 s2 到字符串 s1。
2	strcat(s1, s2); 连接字符串 s2 到字符串 s1 的末尾。
3	strlen(s1); 返回字符串 s1 的长度。
4	strcmp(s1, s2); 如果 s1 和 s2 是相同的，则返回 0；如果 s1s2 则返回大于 0。
5	strchr(s1, ch); 返回一个指针，指向字符串 s1 中字符 ch 的第一次出现的位置。
6	strstr(s1, s2); 返回一个指针，指向字符串 s1 中字符串 s2 的第一次出现的位置。

eg：

#include
#include
 
int main ()
{
   char str1[14] = "runoob";
   char str2[14] = "google";
   char str3[14];
   int  len ;
 
   /* 复制 str1 到 str3 */
   strcpy(str3, str1);
   printf("strcpy( str3, str1) :  %s\n", str3 );
 
   /* 连接 str1 和 str2 */
   strcat( str1, str2);
   printf("strcat( str1, str2):   %s\n", str1 );
 
   /* 连接后，str1 的总长度 */
   len = strlen(str1);
   printf("strlen(str1) :  %d\n", len );
 
   return 0;
}

strcpy( str3, str1) :  runoob
strcat( str1, str2):   runoobgoogle
strlen(str1) :  12

第二项

C 结构体

结构是 C 编程中另一种用户自定义可用数据类型，允许储存不同类型的数据项。

结构体中的数据成员可是基本数据类型（如 int、float、char 等），可是其他结构体类型、指针类型等。

结构用于表示一条记录。

定义结构

结构体定义由关键字 struct 和结构体名组成，结构体名可以根据需要自行定义。

struct 语句定义了一个包含多个成员的新数据类型

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

tag 是结构体标签。

member-list 是标准的变量定义，比如 int i; 或者 float f;  ，或者其他有效的变量定义。

variable-list 结构变量，定义在结构的末尾，最后一个分号之前，可以指定一个或多个结构变量。

eg：

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

tag、member-list、variable-list 这 3 部分至少要出现 2 个。

eg-1://此声明声明了拥有3个成员的结构体，分别为整型的a，字符型的b和双精度的c
//同时又声明了结构体变量s1
//这个结构体并没有标明其标签

struct
{
    int a;
    char b;
    double c;
} s1;

eg-2://此声明声明了拥有3个成员的结构体，分别为整型的a，字符型的b和双精度的c

//结构体的标签为SIMPLE,没有声明变量


struct SIMPLE
{
    int a;
    char b;
    double c;
};

//用SIMPLE标签的结构体，另外声明了变量t1、t2、t3
struct SIMPLE t1, t2[20], *t3;
 

eg-3://也可以用typedef创建新类型

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

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

eg-4://此结构体的声明包含了其他的结构体

struct COMPLEX
{
    char string[100];
    struct SIMPLE a;
};

eg-5://此结构体的声明包含了指向自己类型的指针

struct NODE
{
    char string[100];
    struct NODE *next_node;
};

eg-6:两个结构体互相包含，则需要对其中一个结构体进行不完整声明

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

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

//结构体B中包含指向结构体A的指针，在A声明完后，B也随之进行声明
struct B
{
    struct A *partner;
    //other members;
};

---

结构体变量的初始化

结构体变量可以在定义时指定初始值。

eg:

#include

struct Books
{
   char  title[50];
   char  author[50];
   char  subject[100];
   int   book_id;
} book = {"C 语言", "ZH_edifier", "编程语言", 000000;

int main()
{
    printf("title : %s\nauthor: %s\nsubject: %s\nbook_id: %d\n", book.title, book.author, book.subject, book.book_id);
}

title : C 语言
author: ZH_edifier
subject: 编程语言
book_id: 000000

访问结构成员

访问结构的成员，使用成员访问运算符（.）。成员访问运算符是结构变量名称和要访问的结构成员之间的一个句号。可用 struct 关键字来定义结构类型的变量。

eg:

#include
#include
 
struct Books
{
   char  title[50];
   char  author[50];
   char  subject[100];
   int   book_id;
};

/* 函数声明 */
void printBook( struct Books *book );
int main( )
{
   struct Books Book1;        /* 声明 Book1，类型为 Books */
   struct Books Book2;        /* 声明 Book2，类型为 Books */
 
   /* Book1 详述 */
   strcpy( Book1.title, "A");
   strcpy( Book1.author, "B"); 
   strcpy( Book1.subject, "C ");
   Book1.book_id = 0;

   /* Book2 详述 */
   strcpy( Book2.title, "a");
   strcpy( Book2.author, "b");
   strcpy( Book2.subject, "c");
   Book2.book_id = 0;
 
   /* 通过传 Book1 的地址来输出 Book1 信息 */
   printBook( &Book1 );

   /* 通过传 Book2 的地址来输出 Book2 信息 */
   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 subject : %s\n", book->subject);
   printf( "Book book_id : %d\n", book->book_id);
}
 

Book title : A
Book author : B
Book subject : C
Book book_id : 0
Book title : a
Book author : b
Book subject : c
Book book_id : 0

结构作为函数参数

您可以把结构作为函数参数，传参方式与其他类型的变量或指针类似。您可以使用上面实例中的方式来访问结构变量：

eg:

#include
#include
 
struct Books
{
   char  title[50];
   char  author[50];
   char  subject[100];
   int   book_id;
};

/* 函数声明 */
void printBook( struct Books book );
int main( )
{
   struct Books Book1;        /* 声明 Book1，类型为 Books */
   struct Books Book2;        /* 声明 Book2，类型为 Books */
 

 /* Book1 详述 */
   strcpy( Book1.title, "A");
   strcpy( Book1.author, "B"); 
   strcpy( Book1.subject, "C ");
   Book1.book_id = 0;

   /* Book2 详述 */
   strcpy( Book2.title, "a");
   strcpy( Book2.author, "b");
   strcpy( Book2.subject, "c");
   Book2.book_id = 0;

  
 
   /* 输出 Book1 信息 */
   printBook( Book1 );

   /* 输出 Book2 信息 */
   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 subject : %s\n", book.subject);
   printf( "Book book_id : %d\n", book.book_id);
}

Book title : A
Book author : B
Book subject : C
Book book_id : 0
Book title : a
Book author : b
Book subject : c
Book book_id : 0
 

指向结构的指针

可定义指向结构的指针，方式与定义指向其他类型变量的指针相似，

struct Books *struct_pointer;

可以在上述定义的指针变量中存储结构变量的地址。为了查找结构变量的地址，需把 & 运算符放在结构名称的前面：

struct_pointer = &Book1;

为了使用指向该结构的指针访问结构的成员，必须使用 -> 运算符：

struct_pointer->title;

使用结构指针来重写:

eg：

#include
#include
 
struct Books
{
   char  title[50];
   char  author[50];
   char  subject[100];
   int   book_id;
};

/* 函数声明 */
void printBook( struct Books *book );
int main( )
{
   struct Books Book1;        /* 声明 Book1，类型为 Books */
   struct Books Book2;        /* 声明 Book2，类型为 Books */
 

 /* Book1 详述 */
   strcpy( Book1.title, "A");
   strcpy( Book1.author, "B"); 
   strcpy( Book1.subject, "C ");
   Book1.book_id = 0;

   /* Book2 详述 */
   strcpy( Book2.title, "a");
   strcpy( Book2.author, "b");
   strcpy( Book2.subject, "c");
   Book2.book_id = 0;

 
   /* 通过传 Book1 的地址来输出 Book1 信息 */
   printBook( &Book1 );

   /* 通过传 Book2 的地址来输出 Book2 信息 */
   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 subject : %s\n", book->subject);
   printf( "Book book_id : %d\n", book->book_id);
}

Book title : A
Book author : B
Book subject : C
Book book_id : 0
Book title : a
Book author : b
Book subject : c
Book book_id : 0
 

结构体大小的计算

可使用 sizeof 运算符来计算结构体的大小，sizeof 返回的是给定类型或变量的字节大小。

对于结构体，sizeof 将返回结构体的总字节数，包括所有成员变量的大小以及可能的填充字节。

eg:

#include

struct Person {
    char name[20];
    int age;
    float height;
};

int main() {
    struct Person person;
    printf("结构体 Person 大小为: %zu 字节\n", sizeof(person));
    return 0;
 

 Person 为结构体，包含了一个字符数组 name、一个整数 age 和一个浮点数 height。

在 main 函数中，声明了一个 Person 类型的变量 person，使用 sizeof 运算符来获取 person 结构体的大小。

使用 printf 函数打印出结构体的大小

结构体 Person 大小为: 28 字节

注意，结构体的实际大小可能会大于成员变量大小的总和，如需要确切地了解结构体的内存布局和对齐方式，可以使用 offsetof 宏和 __attribute__((packed)) 属性等进一步控制和查询结构体的大小和对齐方式。