基于Linux的C++ Part 6 复合数据类型

ゝ一纸荒年。 2022-10-11 14:53 12阅读 0赞

### 基于Linux的C++ Part 6 复合数据类型 ###

*  字 符
 *   *  字符类型、字符文字与量
     *  字符量的数学运算
     *  标准字符特征库
 *  数组
 *   *  数组的意义与性质
     *  数组的存储表示
     *  数组元素的初始化
     *  数组元素的访问
     *  数组与函数
     *  多维数组
 *  结构体
 *   *  结构体的意义与性质
     *  结构体的存储表示
     *  结构体数据对象的访问
     *  结构体与函数
 *  编程实践

# 字 符 #

## 字符类型、字符文字与量 ##

*  定义格式：`char ch; const char cch = 'C';`
 *  字符文字使用单引号对
 *  实际存储时字符类型量存储字符的对应 ASCII 值
 *  可使用 `signed` 与 `unsigned` 修饰字符类型

//字符表示的等价性
    char a = 'A';
    char a = 65;
    char a = 0101;
    char a = 0x41;

#include <iostream>
    using namespace std;
    int main(){ 
        char b ='B';
        char a=65;
        cout << "char b = " << b << endl;
        cout << "char a = " << a << endl;
        return 0;
    }
    运行结果
    char b = B
    char a = A

## 字符量的数学运算 ##

*  编写函数，判断某个字符是否为数字

bool IsDigit( char c ) 
    {  
    	if( c >= '0' && c <= '9' ) 
    		return true; 
    	else 
    		return false; 
    }
    
    bool IsDigit( char c )
    { 
    	if( c >= 48 && c <= 57 )
    		return true;
    	else
    		return false;
     }

*  编写函数，将字符转换为大写字符

char ToUpperCase( char c )
    { 
    if( c >= 'a' && c <= 'z' )
    return c – 'a' + 'A';
    else
    return c;
    }

## 标准字符特征库 ##

*  C 标准字符特征库：`ctype.h/cctype`

//标准字符特征库常用函数
    bool isalnum( char c );
    bool isalpha( char c );
    bool isdigit( char c );
    bool islower( char c );
    bool isspace( char c );
    bool isupper( char c );
    char tolower( char c );
    char toupper( char c );

# 数组 #

## 数组的意义与性质 ##

数组的定义
    定义格式：元素类型 数组名称[常数表达式];
    示例：int a[8]; /* 定义包含 8 个整数元素的数组 */
    特别说明
    常数表达式必须是常数和常量，不允许为变量
    错误示例：int count = 8; int c[count];
    数组元素编号从 0 开始计数，元素访问格式为 a[0]、a[1]、……
    ******不允许对数组进行整体赋值操作，只能使用循环逐一复制元素
    错误示例：int a[8], b[8]; a = b;
    意义与性质
    将相同性质的数据元素组织成整体，构成单一维度上的数据序列

## 数组的存储表示 ##

![在这里插入图片描述][20210701150526360.png]

数组的地址
    数组的基地址：数组开始存储的物理位置
    数组首元素的基地址：数组首个元素开始存储的物理地址，数值上总是与数组基地址相同
    “&”操作符：&a 获得数组的基地址；&a[0] 获得数组首元素的基地址
    设数组基地址为 p，并设每个元素的存储空间为 m，则第 i 个元素的基地址为 p + mi

#include <iostream>
    using namespace std;
    int main(){ 
        int a[8];
        int i;
        for (i=0;i<8;i++){ 
            a[i]=0+i;
        }
    
        cout << "The first addr for a[8] is " << &a[0] << endl;
        cout << "The addr of a[0] is " << &a[0]<< endl;
        for (i=0;i<8;i++){ 
            cout << "a[" << i <<"] = " << a[i] << endl;
        }
        return 0;
    }
    运行结果
    The first addr for a[8] is 0x7fff85cec850
    The addr of a[0] is 0x7fff85cec850
    a[0] = 0
    a[1] = 1
    a[2] = 2
    a[3] = 3
    a[4] = 4
    a[5] = 5
    a[6] = 6
    a[7] = 7

## 数组元素的初始化 ##

*  基本初始化格式

定义格式：元素类型 数组名称[元素个数] = {  值1, 值2, 值3, …… };
    示例一：
    int a[8] = {  1, 2, 3, 4, 5, 6, 7, 8 };

*  初始化时省略元素个数表达式

在全部元素均初始化时可以不列写元素个数，使用 sizeof 操作符可以获得元素个数
    示例二：
    int a[] = {  1, 2, 3, 4, 5, 6, 7, 8 };
    int num_of_elements = sizeof( a ) / sizeof( a[0] );
    sizeof(a) 获取数组存储空间大小（以字节为单位），sizeof(a[0]) 获取数组首元素的存储空间大小

## 数组元素的访问 ##

*  数组基本操作示例  
    编写程序，使用数组存储用户输入的 5 个整数，并计算它们的和

#include <iostream>
    using namespace std;
    int main()
    { 
    	int i, a[5], result = 0;
    	for( i = 0; i < 5; i++ ){ 
    		cout << "Integer No. " << i + 1 << ": ";
    		cin >> a[i];
    	}
    	for( i = 0; i < 5; i++ )
    		result += a[i];
    	cout << "The sum of elements of the array is " << result << endl;
    }
    运行结果：
    Integer No. 1: 5
    Integer No. 2: 4
    Integer No. 3: 3
    Integer No. 4: 2
    Integer No. 5: 1
    The sum of elements of the array is 15

## 数组与函数 ##

*  数组元素作为函数**实际参数**

int Add( int x, int y ){  return( x + y ); }
    int a[2] = {  1, 2 }, sum;
    sum = Add( a[0], a[1] );

*  数组整体作为函数**形式参数**

数组整体作为函数形式参数
    基本格式：返回值类型 函数名称( 元素类型 数组名称[], 元素个数类型 元素个数 )
    示例：void GenerateIntegers( int a[], unsigned int n );
    特别说明：作为函数形式参数时，数组名称后的中括号内不需列写元素个数，必须使用单独的参数传递元素个数信息

编写函数，随机生成 n 个位于[lower, upper]区间的整数并保存到数组中
    void GenerateIntegers( int a[], unsigned int n, int lower, int upper )
    { 
    unsigned int i;
    Randomize();
    for( i = 0; i < n; i++ )
    a[i] = GenerateRandomNumber( lower, upper );
    }

*  数组作为函数参数优势

如果直接书写常数：只能操作 8 个元素的数组！
    void GenerateIntegers( int a[8], int lower, int upper )
    { 
    unsigned int i;
    Randomize();
    for( i = 0; i < 8; i++ )
    a[i] = GenerateRandomNumber( lower, upper );
    }
    
    如果不写常数：不知道元素个数，易出错
    void GenerateIntegers( int a[], int lower, int upper )
    { 
    ……
    }
    
    直接书写变量：错误！
    /* 数组元素个数不允许为量 */
    void GenerateIntegers( int a[n], int lower, int upper )
    { 
    ……
    }
    调用格式
    	使用单独数组名称作为函数实际参数，传递数组基地址而不是数组元素值
    	形式参数与实际参数使用相同存储区，对数组形式参数值的改变会自动反应到实际参数中
    #define NUMBER_OF_ELEMENTS 8
    const int lower_bound = 10;
    count int upper_bound = 99;
    int a[NUMBER_OF_ELEMENTS];
    GenerateIntegers( a, NUMBER_OF_ELEMENTS, lower_bound, upper_bound);

实例：
    编写程序，随机生成8个10～99之间的整数保存到数组中，然后将这些元素颠倒过来
    库函数：arrmanip.h
    void GenerateIntegers( int a[], unsigned int n, int lower, int upper );
    void ReverseIntegers( int a[], unsigned int n );
    void SwapIntegers( int a[], unsigned int i, unsigned int j );
    void PrintIntegers( int a[], unsigned int n );
    
    主函数：main.cpp
    #include <iostream>
    #include "arrmanip.h"
    using namespace std;
    #define NUMBER_OF_ELEMENTS 8
    const int lower_bound = 10;
    const int upper_bound = 99;
    int main()
    { 
    int a[NUMBER_OF_ELEMENTS];
    GenerateIntegers( a, NUMBER_OF_ELEMENTS, lower_bound, upper_bound );
    cout << "Array generated at random as follows: \n";
    PrintIntegers( a, NUMBER_OF_ELEMENTS );
    SwapIntegers( a, NUMBER_OF_ELEMENTS );
    cout << "After all elements of the array reversed: \n";
    PrintIntegers( a, NUMBER_OF_ELEMENTS );
    return 0;
    }
    函数：arrmanip.cpp
    #include <iostream>
    #include "random.h"
    #include "arrmanip.h"
    using namespace std;
    void GenerateIntegers( int a[], unsigned int n, int lower, int upper )
    { 
    unsigned int i;
    Randomize();
    for( i = 0; i < n; i++ )
    a[i] = GenerateRandomNumber( lower, upper );
    }
    void SwapIntegers( int a[], unsigned int n )
    { 
    unsigned int i;
    for( i = 0; i < n / 2; i++ )
    SwapIntegers( a, i, n - i - 1 );
    }
    void SwapIntegers( int a[], unsigned int i, unsigned int j )
    { 
    int t;
    t = a[i], a[i] = a[j], a[j] = t;
    }
    void PrintIntegers( int a[], unsigned int n )
    { 
    unsigned int i;
    for( i = 0; i < n; i++ )
    cout << setw(3) << a[i];
    cout << endl;
    }

## 多维数组 ##

*  多维数组的定义

定义格式：元素类型 数组名称[常数表达式1] [常数表达式2]…;
    示例一：int a[2][2]; /* 2×2 个整数元素的二维数组 */
    示例二：int b[2][3][4]; /* 2×3×4 个整数元素数组 */

*  多维数组的初始化

与一维数组类似： int a[2][3] = { 1, 2, 3, 4, 5, 6};
    单独初始化每一维： int a[2][3] = {  { 1, 2, 3}, { 4, 5, 6} };

*  多维数组的存储布局  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tla2VfTWVtb3J5_size_16_color_FFFFFF_t_70]
 *  实战练习：测量湖泊水深  
    在湖面上等距离打上网格，分别测量每个网格的水深，就可以从整体上表示湖泊的情况。图中每个网格中的数字表示水深，值为 0 的表示湖岸，数字 1～5 表示水深（单位为米），每网格对应实际面积为5m×5m。编写程序，计算湖泊的面积和平均水深

测量湖泊水深程序代码
    #include <iostream>
    using namespace std;
    #define NUM_OF_X_GRIDS 9
    #define NUM_OF_Y_GRIDS 4
    static const double lake_region_depths[NUM_OF_Y_GRIDS][NUM_OF_X_GRIDS] =
    { 
    {  0.0, 0.0, 1.0, 2.0, 2.0, 3.0, 0.0, 0.0, 0.0 },
    {  0.0, 2.0, 3.0, 5.0, 5.0, 3.0, 2.0, 0.0, 0.0 },
    {  0.0, 1.0, 4.0, 3.0, 4.0, 2.0, 2.0, 1.0, 0.0 },
    {  0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 1.0, 1.0, 0.0 }
    };
    const double lake_grid_width = 5.0;
    
    int main()
    { 
    double num_of_lake_grids = 0.0, lake_area = 0.0;
    double total_lake_depth = 0.0, mean_lake_depth = 0.0;
    unsigned int i, j;
    for( i = 0; i < NUM_OF_Y_GRIDS; i++ ){ 
    for( j = 0; j < NUM_OF_X_GRIDS; j++ ){ 
    if( lake_region_depths[i][j] > 0 ){ 
    num_of_lake_grids += 1.0;
    total_lake_depth += lake_region_depths[i][j];
    }
    }
    }
    lake_area = lake_grid_width * lake_grid_width * num_of_lake_grids;
    mean_lake_depth = total_lake_depth / num_of_lake_grids;
    cout << "Area of the lake is " << lake_area << "(m2)" << endl;
    cout << "Mean depth of the lake is " << mean_lake_depth << "(m)" << endl;
    return 0;
    }

# 结构体 #

## 结构体的意义与性质 ##

*  结构体的意义  
    与数组的最大差别：不同类型数据对象构成的集合  
    当然也可以为相同类型的但具体意义或解释不同的数据对象集合
 *  结构体类型的定义：注意类型定义后面的分号

struct 结构体名称 { 
    成员类型 1 成员名称 1;
    成员类型 2 成员名称 2;
    ……
    成员类型 n 成员名称 n;
    };

*  结构体类型示例

示例一：日期结构体
    struct DATE{ 
    	int year;
    	int month;
    	int day;
    };
    示例二：复数结构体
    struct COMPLEX{ 
    	double real;
    	double imag;
    }

*  结构体类型的声明  
    仅仅引入结构体类型的名称，而没有给出具体定义，其具体定义在其他头文件中或本文件后续位置  
    struct COMPLEX;
 *  实例：如何表示学生信息？

成员：整数类型的学号 id、
    字符串类型的姓名 name、性别（单独定义枚举类型）gender、
    年龄 age、
    字符串类型的地址 addr
    enum GENDER{  FEMALE, MALE };
    struct STUDENT
    { 
    int id;
    STRING name; // 假设已有字符串类型的定义
    GENDER gender;
    int age;
    STRING addr;
    };

## 结构体的存储表示 ##

*  按照成员定义顺序存放  
    ![在这里插入图片描述][20210713154948149.png]
 *  特殊情况  
    因为不同硬件和编译器的原因，不同类型的成员可能会按照字（两个字节）或双字（四个字节）对齐后存放  
    使用 sizeof 获得结构体类型量占用空间大小（以字节为单位），下述两种使用方式均可

sizeof date;
    sizeof( date );

## 结构体数据对象的访问 ##

*  结构体类型的变量与常量：按普通量格式定义

示例一：DATE date;
    示例二：STUDENT zhang_san;
    示例三：STUDENT students[8];

*  结构体量的初始化

示例四：DATE date = {  2008, 8, 8 };

*  结构体量的赋值

与数组不同，结构体量可直接赋值，拷贝过程为逐成员一一复制
    示例五：DATE new_date; new_date = date;

*  结构体数据对象的访问

使用点号操作符“.”解析结构体量的某个特定成员
    示例一：DATE date; date.year = 2008; date.month = 8; date.day = 8;

*  嵌套结构体成员的访问

可以连续使用点号逐层解析
    示例二： struct FRIEND{  int id; STRING name; DATE birthday; };
    FRIEND friend;
    friend.birthday.year = 1988;

*  复杂结构体成员的访问

严格按照语法规范进行
    示例三： FRIEND friends[4];
    friends[0].birthday.year = 1988;

## 结构体与函数 ##

示例1：编写一函数，使用结构体类型存储日期，并返回该日在该年的第几天信息，具体天数从 1 开始计数  
例如 2016 年 1 月 20 日返回 20，2 月 1 日返回 32

unsigned int GetDateCount( DATE date )
    { 
    /* 静态变量意义：保持变量内容的持久性 - 有时候，我们希望函数中局部变量的值在函数调用结束之后不会消失，而仍然保留其原值。 - 即它所占用的存储单元不释放，在下一次调用该数时，其局部变量的值仍然存在，也就是上一次函数调用结束时的值 - / static unsigned int days_of_months[13] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }; unsigned int i, date_id = 0; for( i = 1; i < date.month; i++ ) date_id += days_of_months[i]; date_id += date.day; if( date.month > 2 && IsLeap(date.year) ) date_id++; return date_id; }

示例2：计算机屏幕上的点使用二维坐标描述。  
编写函数，随机生成一个屏幕上的点。设计算机屏幕分辨率为 1920×1200，屏幕坐标总是从 0 开始计数

struct POINT{  int x, y; };
    const int orignal_point_x = 0;
    const int orignal_point_y = 0;
    const int num_of_pixels_x = 1920;
    const int num_of_pixels_y = 1200;
    POINT GeneratePoint()
    { 
    POINT t;
    t.x = GenerateRandomNumber( orignal_point_x, num_of_pixels_x - 1 );
    t.y = GenerateRandomNumber( orignal_point_y, num_of_pixels_y - 1 );
    return

# 编程实践 #

*  1.编写函数Sort，对包含n个元素的整数数组a，按从小到大顺序排序。此问题有多种算法，不同算法的效率可能不同。
 *  2.编写函数Search，对于已排序的包含n个元素的整数数组a，在其中查找整数key。如果该整数在数组中，函数返回true，否则返回false。

[20210701150526360.png]: /images/20221005/42c8b1de74ac4ec4a61cb9e5a407205b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tla2VfTWVtb3J5_size_16_color_FFFFFF_t_70]: /images/20221005/7cbdeb36a7014266be13ff36294a0794.png
[20210713154948149.png]: /images/20221005/c8cede213c9942a4aa5575a5c80b5cb3.png