C++ 数组、指针、数组指针、指针数组、多级指针、STL-map、结构体的初始化及其初始化赋值

C++ 数组、指针、数组指针、指针数组、多级指针、STL-map、结构体的初始化及其初始化赋值
- C++ 数组、指针、数组指针、指针数组、多级指针
- - 数组
  - - 一维数组初始化：
    - 二维数组初始化：
    - - 运算表达式的优先级 + 结合律
      - 数组【指针】：不要使用，这一意味着你的【指针】指向的是一片连续的空间【数组】，即指向静态数组
      - 指向int的指针【数组】
      - 指向字符的指针【数组】
      - 内存图
      - 几种写法：初始化、new
      - 内存图
        错误提示：
    - 多维数组初始化：
- C++ 初始化赋值
- - 数组：一维数组、二维数组、
  - STL——map
  - 结构体

C++ 数组、指针、数组指针、指针数组、多级指针、STL-map、结构体的初始化及其初始化赋值

C++ 数组、指针、数组指针、指针数组、多级指针

数组

一维数组初始化：

T arr[] = { 1, 2, 2 };
A* array_p = new A[5];int *pia = new int[10]; // 每个元素都没有初始化
int *pia2 = new int[10] (); // 每个元素初始化为0int value[100]; // value[i]的值【不定】，没有初始化
int value[100] = {1,2}; 
// value[0]和value[1]的值分别为1和2，
// 而没有定义的value[i>1]，则【初始化为0】int* value = new int[n]; // 未初始化delete []value; // 一定不能忘了删除数组空间

二维数组初始化：

运算表达式的优先级 + 结合律

从右至左，表示先算右边，再算左边。
[]优先级最高，先 a[]

优先级第二稿，后 *a[] === *(a[])

数组【指针】：不要使用，这一意味着你的【指针】指向的是一片连续的空间【数组】，即指向静态数组

#include <stdio.h>
#include <stdlib.h>
int main()
{int a[3][4] = { { 0, 1, 2, 3 },{ 4, 5, 6, 7 },{ 8, 9, 10, 11 } };int(*p)[4]; // 指向静态数组p = a; // 指向静态数组printf("%d,%d,%d,%d\n", sizeof(*(p)),sizeof(*(p + 1)),sizeof(*(p + 2)),sizeof(*(p + 3)));printf("%d\n", **p);//a[0][0]printf("%d\n", *(*(p + 1)));//a[1][0]system("pause");return 0;

在这里插入图片描述

指向int的指针【数组】

想要让【数组】存储【指向 int 或 char 或其他数据类型的指针】

#include <iostream>using namespace std;
const int MAX = 3;int main ()
{int  var[MAX] = {10, 100, 200};int *ptr[MAX];结合：  int * (ptr[MAX]);  首先是一个数组for (int i = 0; i < MAX; i++){ptr[i] = &var[i]; // 赋值为整数的地址}for (int i = 0; i < MAX; i++){cout << "Value of var[" << i << "] = ";cout << *ptr[i] << endl;}return 0;
}
--------------------------------------------------
Value of var[0] = 10
Value of var[1] = 100
Value of var[2] = 200

指向字符的指针【数组】

想要让【数组】存储【指向 int 或 char 或其他数据类型的指针】

#include <iostream>using namespace std;
const int MAX = 4;int main ()
{
结合： const char* (names[MAX])  首先是一个数组const char *names[MAX] = {"Zara Ali","Hina Ali","Nuha Ali","Sara Ali",};for (int i = 0; i < MAX; i++){cout << "Value of names[" << i << "] = ";cout << names[i] << endl;}return 0;
}
----------------------------------
Value of names[0] = Zara Ali
Value of names[1] = Hina Ali
Value of names[2] = Nuha Ali
Value of names[3] = Sara Ali

内存图

	int (*a)[10];    //*a = int[10],一个指向  【包含10个整数元素【数组】】的  【指针】，是一个指针，内容是一个地址，地址处是连续10个int，即地址处是int[10]想要让【数组】存储【指向 int 或 char 或其他数据类型的指针】指向整数的指针数组int* a[10];   int *a[10];    //a = int*[10], 一个有10个  【指向整数的指针】元素的  【数组】，是一个数组，内容是int*数组，

第一行代码：int* a[10];
它表示一个包含10个元素的【数组a】，每个【元素】都是指向int类型数据的【指针】。
对应的内存结构如下：

                           |--------------|
a[0]  --->  |              |      int     ||--------------|
a[1]  --->  |              |      int     ||--------------|
a[2]  --->  |              |      int     ||--------------||        .             .           .|        .             .           .|        .             .           .|--------------| 
a[9]  --->  |              |      int     ||--------------|

第二行代码：int (*a)[10];
它表示一个指向 一个包含10个整数的int类型数组 的【指针a】。
对应的内存结构如下：

                  |--------------|--------------|--------------|--------------|--------------|--------------|--------------|--------------|--------------|--------------|a  --->      |       [0]    |       [1]    |       [2]    |       [3]    |       [4]    |       [5]    |       [6]    |       [7]    |       [8]    |       [9]    ||--------------|--------------|--------------|--------------|--------------|--------------|--------------|--------------|--------------|--------------||      int     |     int      |     int      |    int       |     int      |     int      |     int      |     int      |     int      |     int      ||--------------|--------------|--------------|--------------|--------------|--------------|--------------|--------------|--------------|--------------|

在这里插入图片描述

几种写法：初始化、new

内存图

new int [m][n] 连续分配mn
new int [m] 分散的int*数组，一共m个
在这里插入图片描述

int value[9][9]; // value[i][j]的值不定，没有初始化
int value[9][9] = {{1,1},{2}}； //value[0][0,1]和value[1][0]的值初始化，其他初始化为0指针方式一：int (*value)[n] = new int[m][n];delete []value; // n必须为【常量】，只有【第一个】m可以不为常数，调用直观。未初始化
指针方式二：创建newint** value = new int* [m];for(i) value[i] = new int[n];删除deletefor(i) delete []value[i];delete []value; // 多次析构，存储麻烦，未初始化
指针方式三： 错误写法，新版本C++会报错，new出来的**int不可以直接转换成int*，有风险
int * value = new int[3][4]; // 数组的存储是按行存储的，一次性分配连续空间，3*4=12
delete []value; // 一定要进行内存释放，否则会造成内存泄露指针形式：如二维数组的访问：value[i][j]*(value[i] + j) 或(*(value + i))[j]

错误提示：

在这里插入图片描述

多维数组初始化：

指针方式： 
int * value = new int[m][3][4]; // 只有第一维可以是变量，其他几维必须都是常量，否则会报错
delete []value; // 一定要进行内存释放，否则会造成内存泄露

C++ 初始化赋值

数组：一维数组、二维数组、

T arr[] = { 1, 2, 2 };
A* array_p = new A[5];int *pia = new int[10]; // 每个元素都没有初始化
int *pia2 = new int[10] (); // 每个元素初始化为0int value[100]; // value[i]的值【不定】，没有初始化
int value[100] = {1,2}; 
// value[0]和value[1]的值分别为1和2，
// 而没有定义的value[i>1]，则【初始化为0】int* value = new int[n]; // 未初始化字符串的长度未知，只需要告诉是个const char*就可以了
const char names[MAX][。。。] = {
const char *(names[MAX]) = { 等价写法
const char *names[MAX] = {"Zara Ali","Hina Ali","Nuha Ali","Sara Ali",
};

STL——map

在 Script.h 定义类，静态成员属性 static RSL_KEY_WORD getEnum(const string sKey);
/// @brief 关键字管理类
/**
*  @author      赵雨腾(zyt1850298154@qq.com)
*  @date        2021/12/16 16:58
*  @class       Key
*  @brief       关键字管理类,预先映射，加速匹配
*  @note        无
*/
class Key {
public:/// @brief 关键字idenum RSL_KEY_WORD {KEY_step,				///< 完整表示一个步骤的所有行为KEY_STD_FUNC_Speak,		///< 计算表达式合成一段文字，调用媒体服务器进行语音合成并播放KEY_STD_FUNC_Listen,	///< 进行语音识别，语音识别的结果调用“自然语言分析服务”分析客户的意愿KEY_STD_FUNC_Branch,	///< 对客户的意愿进行分支处理，不同的意愿，跳转到不同的StepKEY_STD_FUNC_Silence,	///< 如果用户不说话，应该跳转到哪个StepKEY_STD_FUNC_Default,	///< 如果客户意愿没有相应匹配，应该跳转到哪个StepKEY_STD_FUNC_Exit,		///< 结束对话};
public:/// @brief 从str映射到关键字id，如果没有找到，报错，退出程序/// @param sKey 输入字符串/// @return 字符串对应的 enum RSL_KEY_WORD static RSL_KEY_WORD getEnum(const string sKey);public:/// @brief 关键字str:关键字enum，作用：加速关键词匹配，然后进行分流static map<string, RSL_KEY_WORD> mSK;
};
Script.cpp 中初始化上述的 static map<string, RSL_KEY_WORD> mSK;
map<string, Key::RSL_KEY_WORD> Key::mSK({{"step",	KEY_step},{"Speak",	KEY_STD_FUNC_Speak},{"Listen",	KEY_STD_FUNC_Listen},{"Branch",	KEY_STD_FUNC_Branch},{"Silence",	KEY_STD_FUNC_Silence},{"Default",	KEY_STD_FUNC_Default},{"Exit",	KEY_STD_FUNC_Exit},}
);

结构体

Person p1 = { "aaa", 18, 100 };block  test = {    .type= 1,    .size = 12,    .name= "version" };----------------------------------------------如果要声明结构体数组，这里介绍一种表驱动型写法，利用上述方法+枚举的形式来定义，个人感觉十分优雅。typede struct block { char name[32];     int type;     int size; 
}block;  enum{     ENUM_NAME,    ENUM_TYPE,     ENUM_SIZE,     ENUM_MAX 
};  const block motor[ENUM_MAX] = {    [ENUM_NAME] = {.name = "version", .type = 1, .size = 32},    [ENUM_TYPE] = {.name = "device", .type = 2, .size = 16},    [ENUM_SIZE] = {.name = "firmware", .type = 3, .size = 8}, 
};