識別哪個結構包含您正在處理的值的聰明方法是什么？-有解無憂

編輯：現在已經發布了完整的代碼，所以你可以編譯。

所以我們是一些第一學期的軟體學生，有點卡在 c 結構體的問題上。堆疊溢位已經幫助了我很多次，所以我想這次我實際上會嘗試詢問，因為我似乎找不到我要找的東西。

我們的邏輯（見下面的代碼）：

主要呼叫 empty_trash
empty_trash（在其引數中）呼叫 compare_trash
通過 4 個區域（結構）比較垃圾決議
比較垃圾檢查我們的資料的平均值是否超過邊距，如果是，則首先檢查該平均值是否高于我們的空結構，該空結構可能具有 0 平均值，然后如果找到更高的平均值。這給我們留下了具有最高平均值的結構的索引
比較垃圾桶將此結構回傳到空垃圾桶，并將索引的 int 指標回傳到 main。
空垃圾然后通過子區域并檢查它們的平均資料并重置超過 margin2 的那些
我們將重置區域回傳到 main
在 main 中，我們有一個結構體 1-4 的陣列。我們將空垃圾回傳的區域賦值給arrayofstructs[index指向后]

在我們看來，這個邏輯是有道理的，但它似乎不起作用，因為我們的程式在 main 中的那一行崩潰了。我們認為這是因為我們沒有在 main 中正確分配結構，但不是 100% 確定。

我們有點困惑，因為當我們單獨測驗這兩個函式時，它們單獨作業得很好，但在一起時卻沒有。

任何幫助將不勝感激 <3

#include <stdlib.h>
#include <stdio.h>
#include <time.h>

#define MARGIN 70
#define MARGIN2 30
#define SIZE 5

struct subarea
{
   int co2_cost, time;
   double average, sensorData[SIZE];
};

struct area
{
   struct subarea sub_area1, sub_area2, sub_area3, sub_area4;
   double average;
};

struct area simmulated_days(struct area area, int lower_random, int upper_random);
struct area average_trash(struct area area);
struct area sensor_data_start(struct area area1);
struct area compare_trash_to_empty(struct area area1, struct area area2, struct area area3, struct area area4, int *);
struct area empty_trash(struct area chosen_area, int *co2_counter_p, int *time_counter_p);

int main(void)
{
   int co2_counter, time_counter;
   int day_counter = 0;
   int *co2_counter_p = &co2_counter;
   int *time_counter_p = &time_counter;
   int area_number;
   srand(time(NULL));

   struct subarea subarea1_1 = {50, 50, 0, {}};
   struct subarea subarea1_2 = {50, 50, 0, {}};
   struct subarea subarea1_3 = {50, 50, 0, {}};
   struct subarea subarea1_4 = {50, 50, 0, {}};
   struct area area1 = {subarea1_1, subarea1_2, subarea1_3, subarea1_4, 0};

   struct subarea subarea2_1 = {50, 50, 0, {}};
   struct subarea subarea2_2 = {50, 50, 0, {}};
   struct subarea subarea2_3 = {50, 50, 0, {}};
   struct subarea subarea2_4 = {50, 50, 0, {}};
   struct area area2 = {subarea2_1, subarea2_2, subarea2_3, subarea2_4, 0};

   struct subarea subarea3_1 = {50, 50, 0, {}};
   struct subarea subarea3_2 = {50, 50, 0, {}};
   struct subarea subarea3_3 = {50, 50, 0, {}};
   struct subarea subarea3_4 = {50, 50, 0, {}};
   struct area area3 = {subarea3_1, subarea3_2, subarea3_3, subarea3_4, 0};

   struct subarea subarea4_1 = {50, 50, 0, {}};
   struct subarea subarea4_2 = {50, 50, 0, {}};
   struct subarea subarea4_3 = {50, 50, 0, {}};
   struct subarea subarea4_4 = {50, 50, 0, {}};
   struct area area4 = {subarea4_1, subarea4_2, subarea4_3, subarea4_4, 0};

   struct area useless_area = {};
   struct area all_areas[5] = {useless_area, area1, area2, area3, area4};
   struct area local_area = {};

   area1 = sensor_data_start(area1);
   area2 = sensor_data_start(area2);
   area3 = sensor_data_start(area3);
   area4 = sensor_data_start(area4);

   int running = 1;
   while (running)
   {
       area1 = simmulated_days(area1, 7, 10);
       area2 = simmulated_days(area2, 4, 7);
       area3 = simmulated_days(area3, 9, 12);
       area4 = simmulated_days(area4, 6, 9);

       for (int i = 0; i < SIZE; i  )
       {
           printf("%lf  |  %lf  |  %lf  |  %lf  |\n", area1.sub_area1.sensorData[i], area2.sub_area1.sensorData[i], area3.sub_area1.sensorData[i], area4.sub_area1.sensorData[i]);
       }

       day_counter  ;
       printf("Day %d\n", day_counter);

       area1 = average_trash(area1);
       area2 = average_trash(area2);
       area3 = average_trash(area3);
       area4 = average_trash(area4);

       printf("hihi\n");
       all_areas[area_number] = empty_trash(compare_trash_to_empty(area1, area2, area3, area4, &area_number), co2_counter_p, time_counter_p);

       printf("titi\n");
       for (int i = 0; i < SIZE; i  )
       {
           printf("Local area %lf\t", local_area.sub_area1.sensorData[i]);
       }
       printf("\n");

       if (day_counter == 2)
       {
           running = 0;
       }
   }
}

struct area simmulated_days(struct area area, int lower_random, int upper_random)
{
   for (int i = 0; i < SIZE; i  )
   {
       area.sub_area1.sensorData[i]  = ((rand() % (upper_random - lower_random   1))   lower_random);
       area.sub_area2.sensorData[i]  = ((rand() % (upper_random - lower_random   1))   lower_random);
       area.sub_area3.sensorData[i]  = ((rand() % (upper_random - lower_random   1))   lower_random);
       area.sub_area4.sensorData[i]  = ((rand() % (upper_random - lower_random   1))   lower_random);
   }
   return area;
}

//Average Trash Function
struct area average_trash(struct area area)
{
   double sum1 = 0, sum2 = 0, sum3 = 0, sum4 = 0;

   for (int i = 0; i < SIZE; i  )
   {
       sum1  = area.sub_area1.sensorData[i];
       sum2  = area.sub_area2.sensorData[i];
       sum3  = area.sub_area3.sensorData[i];
       sum4  = area.sub_area4.sensorData[i];
   }
   area.sub_area1.average = sum1 / SIZE;
   area.sub_area2.average = sum2 / SIZE;
   area.sub_area3.average = sum3 / SIZE;
   area.sub_area4.average = sum4 / SIZE;
   area.average = (area.sub_area1.average   area.sub_area2.average   area.sub_area3.average   area.sub_area4.average) / 4;

   return area;
}

struct area sensor_data_start(struct area area1)
{
   double x = 75;

   for (int i = 0; i < SIZE; i  )
   {
       area1.sub_area1.sensorData[i] = x;
       area1.sub_area2.sensorData[i] = x;
       area1.sub_area3.sensorData[i] = x;
       area1.sub_area4.sensorData[i] = x;
   }
   return area1;
}

struct area compare_trash_to_empty(struct area area1, struct area area2, struct area area3, struct area area4, int *area_number_p)
{
   struct area local_area = {};
   int i, highBlock = 0;
   struct area block[5] = {local_area, area1, area2, area3, area4};

   for (i = 1; i <= 4; i  )
   {
       if (block[i].average >= MARGIN)
       {
           if (block[i].average > block[highBlock].average)
           {
               highBlock = i;
           }
       }
   }
   *area_number_p = highBlock;
   return block[highBlock];
}

struct area empty_trash(struct area chosen_area, int *co2_counter_p, int *time_counter_p)
{
   int co2_counter = 0;
   int time_counter = 0;
   
   if (chosen_area.sub_area1.average > MARGIN2)
   {
       co2_counter  = chosen_area.sub_area1.co2_cost;
       time_counter  = chosen_area.sub_area1.time;
       chosen_area.sub_area1.average = 0;
       for (int i = 0; i < SIZE; i  )
       {
           chosen_area.sub_area1.sensorData[i] = 0;
           printf("ET %lf\t", chosen_area.sub_area1.sensorData[i]);
       }
       printf("\n");
   }
   if (chosen_area.sub_area2.average > MARGIN2)
   {
       co2_counter  = chosen_area.sub_area2.co2_cost;
       time_counter  = chosen_area.sub_area2.time;
       chosen_area.sub_area2.average = 0;
       for (int i = 0; i < SIZE; i  )
       {
           chosen_area.sub_area2.sensorData[i] = 0;
       }
   }
   if (chosen_area.sub_area3.average > MARGIN2)
   {
       co2_counter  = chosen_area.sub_area3.co2_cost;
       time_counter  = chosen_area.sub_area3.time;
       chosen_area.sub_area3.average = 0;
       for (int i = 0; i < SIZE; i  )
       {
           chosen_area.sub_area3.sensorData[i] = 0;
       }
   }
   if (chosen_area.sub_area4.average > MARGIN2)
   {
       co2_counter  = chosen_area.sub_area4.co2_cost;
       time_counter  = chosen_area.sub_area4.time;
       chosen_area.sub_area4.average = 0;
       for (int i = 0; i < SIZE; i  )
       {
           chosen_area.sub_area4.sensorData[i] = 0;
       }
   }

   *co2_counter_p = co2_counter;
   *time_counter_p = time_counter;
   return chosen_area;
}

uj5u.com熱心網友回復：

我的原評論：

旁注：每當我看到（例如）v1 v2 v3 v4 v5 我想用陣列 v[5] 替換它。所以，在 struct area 中，你需要： struct subarea sub_area[5]; 這將大大簡化您的代碼。您已經在主要內容中執行了此操作 – Craig Estey

你的回應：

@Craig Estey Ye 對除錯器還沒有豐富的經驗，通常只使用 printfs，但聽起來很有幫助，所以 youtube 一個指南旁注：非常有用，我們一開始沒有預見到這一點，但會簡化這么多，ty4input –賽博

我做得更好（？）我已經對您的代碼進行了初步重組。我相信這對你自己以外的其他人也會有幫助。

對不起，但是（我是善意地這么說），代碼需要大量重組。純粹的[不必要的]復雜性可能會掩蓋許多錯誤。

注意事項：

struct通過值傳遞是危險的。這是合法的，但它使代碼變得復雜。通過指標傳遞的時間為 99.44%。您可以“就地”修改給定的結構，而不必[再次按值]回傳它。
了解如何使用指向“當前”元素的指標而不是索引來遍歷陣列。您將在FORALL下面的回圈中看到這一點。
不要“復制”代碼。注意使用陣列時會發生什么。而不是（例如）代碼的四個副本，我們有一個
如果我們有 10,000 個區域，而不是 4 個區域（例如area1、area2、area3、area4）。您會像 (eg) 中那樣復制代碼 10,000 次嗎？empty_trash
我添加typedef了你的兩個struct來簡化事情。
我添加了一些高級技術，例如使用FORALL宏來遍歷陣列。

我使用前處理器條件來表示舊代碼與新代碼：

#if 0
// old code
#else
// new code
#endif

我已經完成了一些/大部分的編輯作業。我已經編譯過了。我可能犯了無數錯誤。但是，它應該給你一個想法：

#include <stdlib.h>
#include <stdio.h>
#include <time.h>

#define MARGIN      70
#define MARGIN2     30
#define SIZE        5

#define NAREA       4

typedef struct subarea {
    int co2_cost, time;
    double average, sensorData[SIZE];
} subarea_t;

typedef struct area {
#if 0
    struct subarea sub_area1, sub_area2, sub_area3, sub_area4;
#else
    subarea_t sub_area[NAREA];
#endif
    double average;
} area_t;

#define COUNTOF(_arr) \
    (sizeof(_arr) / sizeof(_arr[0]))
#define FORALL(_ptr,_arr) \
    __typeof__(_arr[0]) *_ptr = &_arr[0];  _ptr < &_arr[COUNTOF(_arr)];    _ptr

void
simulated_days(area_t *area, int lower_random, int upper_random)
{

    for (FORALL(sub,area->sub_area)) {
        for (FORALL(data,sub->sensorData)) {
            *data  = ((rand() % (upper_random - lower_random   1))  
                lower_random);
        }
    }
}

//Average Trash Function
void
average_trash(area_t *area)
{
    double sum[NAREA] = { 0 };
    int i;

#if 0
    for (int i = 0; i < SIZE; i  ) {
        sub[i] = a
        sum1  = area.sub_area1.sensorData[i];
        sum2  = area.sub_area2.sensorData[i];
        sum3  = area.sub_area3.sensorData[i];
        sum4  = area.sub_area4.sensorData[i];
    }
#else
    for (FORALL(sub,area->sub_area),   i) {
        i = 0;
        for (FORALL(data,sub->sensorData),   i)
            sum[i]  = *data;
    }
#endif

#if 0
    area.sub_area1.average = sum1 / SIZE;
    area.sub_area2.average = sum2 / SIZE;
    area.sub_area3.average = sum3 / SIZE;
    area.sub_area4.average = sum4 / SIZE;
#else
    i = 0;
    for (FORALL(sub,area->sub_area),   i)
        sub->average = sum[i] / SIZE;
#endif

#if 0
    area.average = (area.sub_area1.average  
        area.sub_area2.average  
        area.sub_area3.average  
        area.sub_area4.average) / 4;
#else
    area->average = 0;

    for (FORALL(sub,area->sub_area))
        area->average  = sub->average;

    area->average /= NAREA;
#endif
}

#if 0
area_t
sensor_data_start(area_t area1)
{
    double x = 75;

    for (int i = 0; i < SIZE; i  ) {
        area1.sub_area1.sensorData[i] = x;
        area1.sub_area2.sensorData[i] = x;
        area1.sub_area3.sensorData[i] = x;
        area1.sub_area4.sensorData[i] = x;
    }
    return area1;
}
#else
void
sensor_data_start(area_t *area)
{
    double x = 75;

    for (FORALL(sub,area->sub_area)) {
        for (FORALL(data,sub->sensorData))
            *data = x;
    }
}
#endif

#if 0
area_t
compare_trash_to_empty(area_t area1, area_t area2, area_t area3, area_t area4, int *area_number_p)
{
    area_t local_area = { };
    int i,
     highBlock = 0;
    area_t block[5] = { local_area, area1, area2, area3, area4 };

    for (i = 1; i <= 4; i  ) {
        if (block[i].average >= MARGIN) {
            if (block[i].average > block[highBlock].average) {
                highBlock = i;
            }
        }
    }
    *area_number_p = highBlock;
    return block[highBlock];
}
#else
area_t *
compare_trash_to_empty(const area_t *blocks, area_t *all_areas)
{
    area_t local_area = { };
    int i, highBlock = 0;
#if 0
    area_t block[5] = { local_area, area1, area2, area3, area4 };
#else
    const area_t *block;
#endif

    for (i = 1;  i < NAREA;    i) {
        block = &blocks[i];
        if (block->average >= MARGIN) {
            if (block->average > blocks[highBlock].average)
                highBlock = i;
        }
    }

    all_areas[highBlock] = blocks[highBlock];

    return &all_areas[highBlock];
}
#endif

#if 0
area_t
empty_trash(area_t chosen_area, int *co2_counter_p, int *time_counter_p)
{
    int co2_counter = 0;
    int time_counter = 0;

    if (chosen_area.sub_area1.average > MARGIN2) {
        co2_counter  = chosen_area.sub_area1.co2_cost;
        time_counter  = chosen_area.sub_area1.time;
        chosen_area.sub_area1.average = 0;
        for (int i = 0; i < SIZE; i  ) {
            chosen_area.sub_area1.sensorData[i] = 0;
            printf("ET %lf\t", chosen_area.sub_area1.sensorData[i]);
        }
        printf("\n");
    }
    if (chosen_area.sub_area2.average > MARGIN2) {
        co2_counter  = chosen_area.sub_area2.co2_cost;
        time_counter  = chosen_area.sub_area2.time;
        chosen_area.sub_area2.average = 0;
        for (int i = 0; i < SIZE; i  ) {
            chosen_area.sub_area2.sensorData[i] = 0;
        }
    }
    if (chosen_area.sub_area3.average > MARGIN2) {
        co2_counter  = chosen_area.sub_area3.co2_cost;
        time_counter  = chosen_area.sub_area3.time;
        chosen_area.sub_area3.average = 0;
        for (int i = 0; i < SIZE; i  ) {
            chosen_area.sub_area3.sensorData[i] = 0;
        }
    }
    if (chosen_area.sub_area4.average > MARGIN2) {
        co2_counter  = chosen_area.sub_area4.co2_cost;
        time_counter  = chosen_area.sub_area4.time;
        chosen_area.sub_area4.average = 0;
        for (int i = 0; i < SIZE; i  ) {
            chosen_area.sub_area4.sensorData[i] = 0;
        }
    }

    *co2_counter_p = co2_counter;
    *time_counter_p = time_counter;
    return chosen_area;
}
#else
void
empty_trash(area_t *chosen_area, int *co2_counter_p, int *time_counter_p)
{
    int co2_counter = 0;
    int time_counter = 0;

    for (FORALL(sub,chosen_area->sub_area)) {
        if (sub->average > MARGIN2) {
            co2_counter  = sub->co2_cost;
            time_counter  = sub->time;
            for (FORALL(data,sub->sensorData))
                *data = 0;
        }
    }

    *co2_counter_p = co2_counter;
    *time_counter_p = time_counter;
}
#endif

int
main(void)
{
    int co2_counter, time_counter;
    int day_counter = 0;
    int *co2_counter_p = &co2_counter;
    int *time_counter_p = &time_counter;
    int area_number;

    srand(time(NULL));

#if 0
    subarea_t subarea1_1 = { 50, 50, 0, {} };
    subarea_t subarea1_2 = { 50, 50, 0, {} };
    subarea_t subarea1_3 = { 50, 50, 0, {} };
    subarea_t subarea1_4 = { 50, 50, 0, {} };
    area_t area1 = { subarea1_1, subarea1_2, subarea1_3, subarea1_4, 0 };

    subarea_t subarea2_1 = { 50, 50, 0, {} };
    subarea_t subarea2_2 = { 50, 50, 0, {} };
    subarea_t subarea2_3 = { 50, 50, 0, {} };
    subarea_t subarea2_4 = { 50, 50, 0, {} };
    area_t area2 = { subarea2_1, subarea2_2, subarea2_3, subarea2_4, 0 };

    subarea_t subarea3_1 = { 50, 50, 0, {} };
    subarea_t subarea3_2 = { 50, 50, 0, {} };
    subarea_t subarea3_3 = { 50, 50, 0, {} };
    subarea_t subarea3_4 = { 50, 50, 0, {} };
    area_t area3 = { subarea3_1, subarea3_2, subarea3_3, subarea3_4, 0 };

    subarea_t subarea4_1 = { 50, 50, 0, {} };
    subarea_t subarea4_2 = { 50, 50, 0, {} };
    subarea_t subarea4_3 = { 50, 50, 0, {} };
    subarea_t subarea4_4 = { 50, 50, 0, {} };
    area_t area4 = { subarea4_1, subarea4_2, subarea4_3, subarea4_4, 0 };
#else
    area_t areamain[NAREA];

    for (FORALL(area,areamain)) {
        for (FORALL(sub,area->sub_area)) {
            sub->co2_cost = 50;
            sub->time = 50;
            sub->average = 50;
            for (FORALL(data,sub->sensorData))
                *data = 0.0;
        }
    }
#endif

#if 0
    area_t useless_area = { };
    area_t all_areas[5] = { useless_area, area1, area2, area3, area4 };
#else
    area_t *all_areas = areamain;
#endif
    area_t local_area = { };

#if 0
    area1 = sensor_data_start(area1);
    area2 = sensor_data_start(area2);
    area3 = sensor_data_start(area3);
    area4 = sensor_data_start(area4);
#else
    for (FORALL(area,areamain))
        sensor_data_start(area);
#endif

    int running = 1;

    while (running) {
        simulated_days(&areamain[0], 7, 10);
        simulated_days(&areamain[1], 4, 7);
        simulated_days(&areamain[2], 9, 12);
        simulated_days(&areamain[3], 6, 9);

#if 0
        for (int i = 0; i < SIZE; i  ) {
            printf("%lf  |  %lf  |  %lf  |  %lf  |\n",
                area1.sub_area1.sensorData[i],
                area2.sub_area1.sensorData[i],
                area3.sub_area1.sensorData[i],
                area4.sub_area1.sensorData[i]);
        }
#else
        for (int i = 0; i < SIZE; i  ) {
            for (FORALL(area,areamain))
                printf("%lf  |",area->sub_area[i]);
            printf("\n");
        }
#endif

        day_counter  ;
        printf("Day %d\n", day_counter);

#if 0
        area1 = average_trash(area1);
        area2 = average_trash(area2);
        area3 = average_trash(area3);
        area4 = average_trash(area4);
#else
        for (FORALL(area,areamain))
            average_trash(area);
#endif

        printf("hihi\n");
#if 0
        all_areas[area_number] =
            empty_trash(compare_trash_to_empty(area1, area2, area3, area4,
                &area_number), co2_counter_p, time_counter_p);
#else
        area_t *area_out = compare_trash_to_empty(areamain,all_areas);
        empty_trash(area_out, co2_counter_p, time_counter_p);
#endif

        printf("titi\n");
#if 0
        for (int i = 0; i < SIZE; i  ) {
            printf("Local area %lf\t", local_area.sub_area1.sensorData[i]);
        }
        printf("\n");
#else
        do {
            subarea_t *sub = area_out->sub_area;
            printf("Local area ");
            for (FORALL(data,sub->sensorData))
                printf("%f\t", *data);
            printf("\n");
        } while (0);
#endif

        if (day_counter == 2) {
            running = 0;
        }
    }
}

轉載請註明出處，本文鏈接：https://www.uj5u.com/yidong/373179.html

標籤：C 解析结构

上一篇：從深層嵌套的json創建資料框

下一篇：使用SSIS或T-SQL將一列帶引號和不帶引號的逗號分隔值拆分為多列