C++ 为什么要使用SomeType[1]而不是SomeType*作为结构中的最后一个成员

我在代码中看到了下一个语句：

SomeType someVar[1];

稍后使用

someVar

作为指向

SomeType

的指针。为什么要这样声明，而不是：

SomeType* someVar;

编辑：正如许多人指出的，我需要指定上下文

struct SomeStruct
{
    size_t count;
    SomeType someVar[1];
};

SomeStruct* str = malloc(sizeof(SomeStruct) + sizeof(SomeType) * count);
str->count = count
...

---

str->someVar

用作从此点开始的

SomeType

元素的

count

数组。

第一个可以被视为指向可能未初始化的

SomeType

的指针（如果它是非POD类型，则初始化）。第二个只是一个悬空的指针

 SomeType someVar[1];
 someVar[0]; //valid
 *someVar;   //valid

vs

---

对于第二个要工作的对象，您需要使其指向有效的对象，因此要么指向现有对象（因此指针就没有意义了），要么指向分配了

new

的新对象，在这种情况下，您必须自己调用

delete

。

第一个可以被视为指向可能未初始化的

SomeType

（如果它是非POD类型，则初始化）的指针。第二个只是一个悬空的指针

 SomeType someVar[1];
 someVar[0]; //valid
 *someVar;   //valid

SomeType someVar[1];

vs

---

对于第二个要工作的对象，您需要使其指向有效的对象，因此要么指向现有对象（因此指针就没有意义了），要么指向分配了

new

的新对象，在这种情况下，您必须自己调用

delete

。

第一个可以被视为指向可能未初始化的

SomeType

（如果它是非POD类型，则初始化）的指针。第二个只是一个悬空的指针

 SomeType someVar[1];
 someVar[0]; //valid
 *someVar;   //valid

SomeType someVar[1];

vs

---

对于第二个要工作的对象，您需要使其指向有效的对象，因此要么指向现有对象（因此指针就没有意义了），要么指向分配了

new

的新对象，在这种情况下，您必须自己调用

delete

。

第一个可以被视为指向可能未初始化的

SomeType

（如果它是非POD类型，则初始化）的指针。第二个只是一个悬空的指针

 SomeType someVar[1];
 someVar[0]; //valid
 *someVar;   //valid

SomeType someVar[1];

vs

对于第二个要工作的对象，您需要使它指向有效的对象，因此既可以指向现有对象（因此指针就没有意义了），也可以指向分配了

new

的新对象，在这种情况下，您必须自己调用

delete

SomeType someVar[1];

someVar

是具有1个元素的类型为

SomeType

的数组

SomeType* someVar;

someVar

是类型为

SomeType

的指针（仍然悬空，您还没有将其指向任何对象）

---

您可以使用数组本身的名称作为指向该数组第一个元素的指针的缩写

someVar

是具有1个元素的类型为

SomeType

的数组

SomeType* someVar;

someVar

是类型为

SomeType

的指针（仍然悬空，您还没有将其指向任何对象）

---

您可以使用数组本身的名称作为指向该数组第一个元素的指针的缩写

someVar

是具有1个元素的类型为

SomeType

的数组

SomeType* someVar;

someVar

是类型为

SomeType

的指针（仍然悬空，您还没有将其指向任何对象）

---

您可以使用数组本身的名称作为指向该数组第一个元素的指针的缩写

someVar

是具有1个元素的类型为

SomeType

的数组

SomeType* someVar;

someVar

是类型为

SomeType

的指针（仍然悬空，您还没有将其指向任何对象）

---

您可以使用数组本身的名称作为指向该数组第一个元素的指针的缩写

---

因为一般来说，它们是不一样的。第一个定义一个SomeType元素数组，另一个定义指向SomeType的指针

第一个为一个元素分配内存，另一个不分配

---

通常：

sizeof（SOmeType[1]）！=sizeof（SomeType*）。

，因为一般来说，它们不一样。第一个定义一个SomeType元素数组，另一个定义指向SomeType的指针

第一个为一个元素分配内存，另一个不分配

---

通常：

sizeof（SOmeType[1]）！=sizeof（SomeType*）。

，因为一般来说，它们不一样。第一个定义一个SomeType元素数组，另一个定义指向SomeType的指针

第一个为一个元素分配内存，另一个不分配

---

通常：

sizeof（SOmeType[1]）！=sizeof（SomeType*）。

，因为一般来说，它们不一样。第一个定义一个SomeType元素数组，另一个定义指向SomeType的指针

第一个为一个元素分配内存，另一个不分配

---

通常：

sizeof（SOmeType[1]）！=sizeof（SomeType*）。

如果您使用SomeType*，您将在某个时候需要一个新的

，因此您必须
删除它以避免泄漏

使用SomeType[]在堆栈上分配，内存管理将为您处理。
如果使用SomeType*，您将在某个时候需要一个
新的
，因此您必须
删除它以避免泄漏

使用SomeType[]在堆栈上分配，内存管理将为您处理。
如果使用SomeType*，您将在某个时候需要一个
新的
，因此您必须
删除它以避免泄漏

使用SomeType[]在堆栈上分配，内存管理将为您处理。
如果使用SomeType*，您将在某个时候需要一个
新的
，因此您必须
删除它以避免泄漏

使用SomeType[]在堆栈上分配，内存管理将为您处理

SomeType-someVar[1]在堆栈上分配内存，并提供