假设我想定义一个结构来表示向量的长度和其值：
struct Vector{
double* x;
int n;
};
现在，假设我想定义一个向量y并为其分配内存。
struct Vector *y = (struct Vector*)malloc(sizeof(struct Vector));
我在互联网上搜索发现，我应该单独为x分配内存。
y->x = (double*)malloc(10*sizeof(double));
但是，看起来我在为 y->x 分配内存时，会分别为 y 和 y->x 两次分配内存，这似乎浪费了内存。 如果您能让我知道编译器实际上是如何工作的，以及正确初始化 y 和 y->x 的方法，那将不胜感激。
不，你并没有为 y->x 分配内存两次。
相反，你为这个结构体（其中包括一个指针）分配了内存，再为指针所指向的内容分配了内存。
可以这样理解：
1 2
+-----+ +------+
y------>| x------>| *x |
| n | +------+
+-----+
实际上，您需要两个分配(1和2)才能存储您所需的所有内容。
此外，您的类型应该是struct Vector *y，因为它是一个指针，在C中不应该转换malloc的返回值。
这可能会隐藏您不想要的某些问题，而且C完全可以隐式地将void*返回值转换为任何其他指针。
当然，您可能希望封装这些向量的创建以使其更易于管理，例如使用以下头文件vector.h：
struct Vector {
double *data; // Use readable names rather than x/n.
size_t size;
};
struct Vector *newVector(size_t sz);
void delVector(struct Vector *vector);
//void setVectorItem(struct Vector *vector, size_t idx, double val);
//double getVectorItem(struct Vector *vector, size_t idx);
然后，在vector.c中，你有用于管理向量的实际函数：
#include "vector.h"
// Atomically allocate a two-layer object. Either both layers
// are allocated or neither is, simplifying memory checking.
struct Vector *newVector(size_t sz) {
// First, the vector layer.
struct Vector *vector = malloc(sizeof (struct Vector));
if (vector == NULL)
return NULL;
// Then data layer, freeing vector layer if fail.
vector->data = malloc(sz * sizeof (double));
if (vector->data == NULL) {
free(vector);
return NULL;
}
// Here, both layers worked. Set size and return.
vector->size = sz;
return vector;
}
void delVector(struct Vector *vector) {
// Can safely assume vector is NULL or fully built.
if (vector != NULL) {
free(vector->data);
free(vector);
}
}
通过这样封装向量管理，您可以确保向量要么完全构建，要么根本没有构建——不存在它们半构建的机会。
这还允许您在不影响客户端的情况下完全更改未来的基础数据结构。例如：
您还可以添加更多功能，例如安全地设置或获取向量值（请参见标头中的注释代码），随着需要的出现而增加。
例如，您可以（作为一种选项）在有效范围之外的设置值时默默地忽略并在获取这些值时返回零。或者您可以引发某种错误，或者尝试在幕后自动扩展向量。(1)
在使用向量方面，一个简单的示例是以下内容（非常基本的）main.c：
#include "vector.h"
#include <stdio.h>
int main(void) {
Vector myvec = newVector(42);
myvec.data[0] = 2.718281828459;
delVector(myvec);
}
(1) 可扩展向量的潜力需要进一步说明。
许多向量实现将容量与大小分开。前者是在需要重新分配之前可以使用的元素数量，后者是实际向量大小（始终<=容量）。
在扩展时，你希望通常以这样的方式扩展，即尽量不频繁进行，因为它可能是一项昂贵的操作。例如，你可以添加比严格必要的多5％，以便在连续添加一个元素的循环中，它不必为每个单个项重新分配。
main 函数来展示如何调用 newVector() 函数？ - MA Bisk原则上你已经做得正确了。对于你想要的，你确实需要两个malloc()。
仅提供一些注释：
struct Vector y = (struct Vector*)malloc(sizeof(struct Vector));
y->x = (double*)malloc(10*sizeof(double));
应该是
struct Vector *y = malloc(sizeof *y); /* Note the pointer */
y->x = calloc(10, sizeof *y->x);
struct Vector{
int n;
double x[];
};
struct Vector *y = malloc(sizeof *y + 10 * sizeof(double));
if(NULL == foo)一样。 - Wernseysizeof *y 可以帮助你避免像写 sizeof(Vector) 时实际想要的是 sizeof(Matrix) 这样的错误。你有多经常犯这样的错误？当你犯错时，你会多快地找到并修复它们呢？我同意这可以增加类型安全性，并且我在自己的代码中也会写 sizeof *y，但这几乎和写 if(NULL == foo) 一样谨慎，目的是为了防止 == 的拼写错误。 - Wernseyy是指向struct Vector的指针，因此sizeof * y表示“y所指向的大小”，即sizeof struct Vector。 - Wernsey*y 处于未求值的上下文中，因此不会被解引用。可能与此相关：https://dev59.com/Y1sW5IYBdhLWcg3wVmGV#35088909 - Seiko Santanastruct Vector y = (struct Vector*)malloc(sizeof(struct Vector)); 不正确。struct Vector *y = (struct Vector*)malloc(sizeof(struct Vector));，因为 y 持有 struct Vector 的指针。malloc() 仅分配足够容纳 Vector 结构体（包括指向 double 和 int 的指针）的内存。malloc() 实际上分配了可容纳 10 个 double 的内存。struct Vector分配内存时，您只为指针x分配内存，即为其值分配空间，该值包含地址。因此，您不会为y.x所引用的块分配内存。请注意保留html标签。第一个 malloc 分配内存给结构体，包括指向 double 类型的指针 x 所需的内存。第二个 malloc 分配内存给 x 指向的 double 值。
struct Vector y = (struct Vector*)malloc(sizeof(struct Vector) + 10*sizeof(double));
y->x = (double*)((char*)y + sizeof(struct Vector));
y->n = 10;
y->x 能够正确对齐以容纳一个 double 类型的值。如果不能，那么你将会得到未定义的行为。 - real-or-random当您执行 malloc(sizeof(struct_name)) 时，它会自动为结构体的完整大小分配内存，您无需为内部的每个元素单独执行 malloc。
使用 -fsanitize=address 标志来检查您如何使用程序内存。
malloc()的返回值转换为类型。我永远不会理解为什么每个人都感觉需要这样做。 :( - unwindvoid *不会自动转换为其他指针，需要进行强制转换（或者，在C++中，当然可以不使用malloc()）。 - unwind