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] (); // 每个元素初始化为0
int 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可以不为常数，调用直观。未初始化
指针方式二：
创建new
int** value = new int* [m];
for(i) value[i] = new int[n];
删除delete
for(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] (); // 每个元素初始化为0
int 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 关键字id
enum RSL_KEY_WORD {
KEY_step, ///< 完整表示一个步骤的所有行为
KEY_STD_FUNC_Speak, ///< 计算表达式合成一段文字，调用媒体服务器进行语音合成并播放
KEY_STD_FUNC_Listen, ///< 进行语音识别，语音识别的结果调用“自然语言分析服务”分析客户的意愿
KEY_STD_FUNC_Branch, ///< 对客户的意愿进行分支处理，不同的意愿，跳转到不同的Step
KEY_STD_FUNC_Silence, ///< 如果用户不说话，应该跳转到哪个Step
KEY_STD_FUNC_Default, ///< 如果客户意愿没有相应匹配，应该跳转到哪个Step
KEY_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
},
};
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
