C++ 数组数据无法在输出中生成正确的计算结果

所以我有一个重量计算器作业，我正在为大学做，我的老师不能解决我的问题。我花了大约三天的时间试图弄明白这一点。我也手动执行了代码，并跟踪了步骤，但无法理解

我没有收到任何错误，但计算结果不符合逻辑

奇怪的是，它是一个非常小的程序，在多个设备上产生相同的结果，所以它不仅仅是我的PC或平板电脑。我认为问题可能首先在于存储重量数据，而不是计算本身

我会尽量不放太多的代码，但同时我想让你们了解我是如何构建这个程序的。我相信result.weight中没有正确存储任何内容

我对C++是相当新的，我已经转换到Pascal了。如果代码中的逻辑有问题，请帮助我解决，因为它在我看来应该是可行的

part_data read_part()
{
    int option;
    part_data result;
    result.name = read_string("Please Enter a name: ");
    result.kind = read_part_kind();
    result.weight = read_float("Please Enter weight: ");
}

float weight_of_kind(part_array &data, partkind kind)
{
    int i = 0;
    float result = 0.0;

    for (i = 0; i< data.num; i++);
    {
        if (data.array[i].kind == kind)
        {
            result += data.array[i].weight;
        }
    }
    return result;
}

float total_weight(part_array &data)
{
    float result = 0.0;
    int i;
    for (i = 0; i < data.num; i++)
    {
        result += data.array[i].weight;
    }
    return result;
}

void calculate_weight(part_array &data)
{
    int i;
    printf("Total weight: %4.2f\n", total_weight(data));
    printf("Total CRITICAL: %4.2f\n", weight_of_kind(data, CRITICAL));
    printf("Total DESIRED: %4.2f\n", weight_of_kind(data, DESIRED));
    printf("Total OPTIONAL: %4.2f\n", weight_of_kind(data, OPTIONAL));
}

这是我在尝试计算多人的权重时得到的输出，按种类分类（关键、期望或可选）

---

更新： 下面是程序中可能帮助我们调试的其他相关函数。我很感激你们给我的帮助，也很感谢你们没有投反对票。我知道这对一些人来说是多么诱人

partkind read_part_kind()
{
        printf("1 - Critical\n");
        printf("2 - Desired\n");
        printf("3 - Optional\n");
    switch( read_integer_range("Please select a part kind: ", 1, 3) )
    {
        case 1: return CRITICAL;
        case 2: return DESIRED;
        default: return OPTIONAL;
    }
}

part_data read_part()
{
    int option;
    part_data result;

    result.name = read_string("Please Enter a name: ");
    result.kind = read_part_kind();
    result.weight = read_float("Please Enter weight: ");

    return result;
}

void add_part(part_array &data)
{
    data.num++;
    data.array = (part_data*) realloc(data.array, sizeof(part_data)*data.num);
    data.array[data.num - 1] = read_part();
}

我希望这段代码有助于理解为什么输入分配不正确以及为什么总权重产生（似乎）随机内存。

您的

readPart（）

函数不返回任何内容，但它应该返回

部分数据。并尝试在
float
中更改变量
weight
，而不是
long
，因为您的演算返回
float

typedef struct {
    my_string name;//array
    partkind kind;
    float weight; // <<<<<<<
} part_data;

您的
readPart（）
函数不返回任何内容，但它应该返回
part\u数据。并尝试在
float
中更改变量
weight
，而不是
long
，因为您的演算返回
float

typedef struct {
    my_string name;//array
    partkind kind;
    float weight; // <<<<<<<
} part_data;

您试图在函数计算权重（）和总权重（）中使用指针部分数据*数组，而不初始化它，这会导致它包含随机垃圾。在使用该阵列之前，应按如下方式为其分配内存：

array = new part_data[n]

其中n是数组中的元素数。在您的情况下，您可能希望n等于data.num

另外，您声明readPart（）函数将返回部分数据，但它不返回任何内容
 您试图在函数计算权重（）和总权重（）中使用指针部分数据*数组，而不初始化它，这会导致它包含随机垃圾。在使用该阵列之前，应按如下方式为其分配内存：

array = new part_data[n]

其中n是数组中的元素数。在您的情况下，您可能希望n等于data.num

另外，您声明readPart（）函数将返回部分数据，但它不返回任何内容
 使用指针而不是引用。我会这样做：

    part_data read_part()
    {
        int option;
        part_data result;
        result.name = read_string("Please Enter a name: ");
        result.kind = read_part_kind();
        result.weight = read_float("Please Enter weight: ");
        return result;
    }

    float weight_of_kind(part_array* data, partkind kind)
    {
        int i = 0;
        float result = 0.0;

        for (i = 0; i< data->num; i++);
        {
            if (data->array[i].kind == kind)
            {
                result += data->array[i].weight;
            }
        }
        return result;
    }

    float total_weight(part_array* data)
    {
        float result = 0.0;
        int i;
        for (i = 0; i < data->num; i++)
        {
            result += data->array[i].weight;
        }
        return result;
    }

    void calculate_weight(part_array* data)
    {
        int i;
        printf("Total weight: %4.2f\n", total_weight(data));
        printf("Total CRITICAL: %4.2f\n", weight_of_kind(data, CRITICAL));
        printf("Total DESIRED: %4.2f\n", weight_of_kind(data, DESIRED));
        printf("Total OPTIONAL: %4.2f\n", weight_of_kind(data, OPTIONAL));
    }

partkind read_part_kind()
{
        printf("1 - Critical\n");
        printf("2 - Desired\n");
        printf("3 - Optional\n");
    switch( read_integer_range("Please select a part kind: ", 1, 3) )
    {
        case 1: return CRITICAL;
        case 2: return DESIRED;
        default: return OPTIONAL;
    }
}

part_data read_part()
{
    int option;
    part_data result;

    result.name = read_string("Please Enter a name: ");
    result.kind = read_part_kind();
    result.weight = read_float("Please Enter weight: ");

    return result;
}

void add_part(part_array* data)
{
    data->num++;
    data->array = (part_data*) realloc(data->array, sizeof(part_data)*data->num);
    data->array[data.num - 1] = read_part();
}

part_数据读取_part（）
{
int选项；
第四部分数据结果；
result.name=读取字符串（“请输入名称：”）；
result.kind=read_part_kind（）；
result.weight=读取浮点数（“请输入重量：”）；
返回结果；
}
浮动权重（零件数组*数据，零件种类）
{
int i=0；
浮动结果=0.0；
对于（i=0；inum；i++）；
{
if（数据->数组[i].kind==kind）
{
结果+=数据->数组[i]。权重；
}
}
返回结果；
}
浮动总重量（部分数组*数据）
{
浮动结果=0.0；
int i；
对于（i=0；inum；i++）
{
结果+=数据->数组[i]。权重；
}
返回结果；
}
无效计算权重（零件数组*数据）
{
int i；
printf（“总重量：%4.2f\n”，总重量（数据））；
printf（“总临界值：%4.2f\n”，重量（数据，临界值））；
printf（“所需总重量：%4.2f\n”，各种重量（数据，所需））；
printf（“可选总量：%4.2f\n”，重量（数据，可选））；
}
partkind阅读部分种类（）
{
printf（“1-关键\n”）；
printf（“2-所需的\n”）；
printf（“3-可选\n”）；
开关（读取整数范围（“请选择零件种类：”，1，3））
{
案例1：返回临界值；
案例2：期望返回；
默认：返回可选；
}
}
部分数据读取部分（）
{
int选项；
第四部分数据结果；
result.name=读取字符串（“请输入名称：”）；
result.kind=read_part_kind（）；
result.weight=读取浮点数（“请输入重量：”）；
返回结果；
}
无效添加零件（零件数组*数据）
{
数据->num++；
数据->数组=（部分数据*）realloc（数据->数组，大小（部分数据）*数据->数值）；
数据->数组[data.num-1]=read_part（）；
}
使用指针而不是引用。我会这样做：

    part_data read_part()
    {
        int option;
        part_data result;
        result.name = read_string("Please Enter a name: ");
        result.kind = read_part_kind();
        result.weight = read_float("Please Enter weight: ");
        return result;
    }

    float weight_of_kind(part_array* data, partkind kind)
    {
        int i = 0;
        float result = 0.0;

        for (i = 0; i< data->num; i++);
        {
            if (data->array[i].kind == kind)
            {
                result += data->array[i].weight;
            }
        }
        return result;
    }

    float total_weight(part_array* data)
    {
        float result = 0.0;
        int i;
        for (i = 0; i < data->num; i++)
        {
            result += data->array[i].weight;
        }
        return result;
    }

    void calculate_weight(part_array* data)
    {
        int i;
        printf("Total weight: %4.2f\n", total_weight(data));
        printf("Total CRITICAL: %4.2f\n", weight_of_kind(data, CRITICAL));
        printf("Total DESIRED: %4.2f\n", weight_of_kind(data, DESIRED));
        printf("Total OPTIONAL: %4.2f\n", weight_of_kind(data, OPTIONAL));
    }

partkind read_part_kind()
{
        printf("1 - Critical\n");
        printf("2 - Desired\n");
        printf("3 - Optional\n");
    switch( read_integer_range("Please select a part kind: ", 1, 3) )
    {
        case 1: return CRITICAL;
        case 2: return DESIRED;
        default: return OPTIONAL;
    }
}

part_data read_part()
{
    int option;
    part_data result;

    result.name = read_string("Please Enter a name: ");
    result.kind = read_part_kind();
    result.weight = read_float("Please Enter weight: ");

    return result;
}

void add_part(part_array* data)
{
    data->num++;
    data->array = (part_data*) realloc(data->array, sizeof(part_data)*data->num);
    data->array[data.num - 1] = read_part();
}

part_数据读取_part（）
{
int选项；
第四部分数据结果；
result.name=读取字符串（“请输入名称：”）；
result.kind=read_part_kind（）；
result.weight=读取浮点数（“请输入重量：”）；
返回结果；
}
浮动权重（零件数组*数据，零件种类）
{
int i=0；
浮动结果=0.0；
对于（i=0；inum；i++）；
{
if（数据->数组[i].kind==kind）
{
结果+=数据->数组[i]。权重；
}
}
返回结果；
}
浮动总重量（部分数组*数据）
{