Question

我有一个名为ball的结构，一些球，一个球阵列和一个我想在阵列中添加新球的函数：

结构：

typedef struct ball{
    BITMAP *image;
    int x;
    int y;
    int vector_x;
    int vector_y;
} ball;

（非工作功能）：

void add_balls(int *num_balls, ball **myballs){
    num_balls++;
    *myballs = realloc(*myballs, *num_balls * sizeof(ball));
    *myballs[*num_balls-1]->x =  rand() % 640;
    *myballs[*num_balls-1]->y = rand() % 480;
    *myballs[*num_balls-1]->vector_x = rand() % 10;
    *myballs[*num_balls-1]->vector_y = rand() % 10;
    *myballs[*num_balls-1]->image = load_bitmap("blue_ball.bmp", NULL); 
 }

和main中的函数调用：

add_balls(&num_balls, &myballs);

对函数的调用失败，并显示以下错误消息：

p.c: In function ‘add_balls’:
p.c:19: error: invalid type argument of ‘unary *’
p.c:20: error: invalid type argument of ‘unary *’
p.c:21: error: invalid type argument of ‘unary *’
p.c:22: error: invalid type argument of ‘unary *’
p.c:23: error: incompatible types in assignment

任何帮助？

这有帮助。它现在编译，但我在运行时遇到分段错误错误。如果感兴趣的话，这是完整的代码：

#include <allegro.h>
#include <stdlib.h>
#include <time.h>
#include <math.h>

#define NUM_BALLS 10

typedef struct ball{
    BITMAP *image;
    int x;
    int y;
    int vector_x;
    int vector_y;
} ball;

void add_balls(int *num_balls, ball **myballs){
    num_balls++;
    myballs = realloc(*myballs, *num_balls * sizeof(ball));
    myballs[*num_balls-1]->x =  rand() % 640;
    myballs[*num_balls-1]->y = rand() % 480;
    myballs[*num_balls-1]->vector_x = rand() % 10;
    myballs[*num_balls-1]->vector_y = rand() % 10;
    myballs[*num_balls-1]->image = load_bitmap("blue_ball.bmp", NULL);  
 }

int main() 
{
    allegro_init();
    install_keyboard();
    srand(time(0));

    install_timer();

    set_color_depth(32);
    set_gfx_mode(GFX_AUTODETECT_WINDOWED, 640,480,0,0);

    BITMAP *buffer = NULL;
    buffer = create_bitmap(640,480);

    ball *myballs;
    myballs  = malloc(NUM_BALLS * sizeof(ball));
    int num_balls = NUM_BALLS;

    BITMAP *bg = NULL;
    bg = load_bitmap("bg.bmp",NULL);

    int i;
    for(i=0;i<num_balls;i++){
        myballs[i].x =  rand() % 640;
        myballs[i].y = rand() % 480;
        myballs[i].vector_x = rand() % 10;
        myballs[i].vector_y = rand() % 10;
        myballs[i].image = load_bitmap("blue_ball.bmp", NULL);
    }

    int bg_vector_x;
    float bg_vector_y;

    while(!key[KEY_ESC]){
        vsync();
        for(i=0;i<num_balls;i++){

            if(myballs[i].x + myballs[i].vector_x > 640 || myballs[i].x + myballs[i].vector_x < 0){
                myballs[i].vector_x *= -1;
            }
            if(myballs[i].y + myballs[i].vector_y > 480 || myballs[i].y + myballs[i].vector_y < 0){
                myballs[i].vector_y *= -1;
            }

            myballs[i].x += myballs[i].vector_x;
            myballs[i].y += myballs[i].vector_y;
        }

        if(key[KEY_UP]){
            add_balls(&num_balls, &myballs);
        }

        clear_bitmap(buffer);

        int ii;     
        for(i=0;i<3;i++){
            for(ii=-1;ii<3;ii++){
                draw_sprite(buffer, bg ,(bg_vector_x%528)+(i*528),100*cos(bg_vector_y) + ii*353);       
            }
        }
        bg_vector_x++;
        bg_vector_y+=0.1;

        for(i=0;i<num_balls;i++){
            draw_sprite(buffer, myballs[i].image, myballs[i].x,myballs[i].y);
        }

        blit(buffer, screen, 0,0,0,0,640,480);
    }

    for(i=0;i<num_balls;i++){
        destroy_bitmap(myballs[i].image);
    }
    free(myballs);
    destroy_bitmap(buffer);
}

END_OF_MAIN()

Answer 1

在你修改过的add_balls函数中增加指针num_balls，你实际上想要增加指针的内容，（* num_balls）++;

Answer 2

*myballs[*num_balls-1]->x

这一次取消引用太多了 - myballs是一个指针数组（或另一种方式，一个指向指针数组的第一个元素的指针） - 只是在myballs前丢失星号，现在你会得到从中可以访问结构的指针（或者，将 - ＆gt;转换为。）。符号 - ＆gt;是从表示该结构的指针访问结构成员的简写，而不是从结构的解引用指针访问结构。

myballs[*num_balls-1]->x

或

(*myballs[*num_balls-1]).x

Answer 3

除了Adam Rosenfield和Baruch Even的答案之外，你应该考虑realloc()失败时会发生什么。

p = realloc(p, s)是危险的，因为当它失败时，它会将指针设置为NULL，但不会释放它过去指向的内存。如果发生这种情况，您的程序将最终泄漏原始内存块（如果它没有先崩溃）。相反，您应该将realloc()的结果分配给另一个变量，以便您可以处理返回NULL的情况。

Answer 4

您的原始代码非常接近正确。第一个问题是相对简单的修复。这条线

num_balls++;

应该是

(*num_balls)++;

您正在递增num_balls指向的位置，而不是递增它指向的值。当你稍后取消引用它时，它指向另一块内存 - 在这个特定的使用场景中，它可能指向main()中变量bg的堆栈上的下一个局部变量。

您的其他问题是操作顺序问题。数组索引具有比解除引用更高的运算符优先级，因此行

*myballs[*num_balls-1]->x = rand() % 640;

相当于

*(myballs[*num_balls-1]->x) = rand() % 640

myballs是指向ball数组的指针。如果*num_balls-1不是0，那么您将访问错误的内存。无论如何，成员变量x不是指针，因此您无法取消引用它，因此编译器会在此处保存语法错误。正确的代码是确保在获取数组索引之前取消引用：

(*myballs)[*num_balls-1].x = rand() % 640;

这可以满足您的需求，即取消引用指针以获取指向原始数组的指针，获取所需的元素，并分配给成员变量x。 add_ball()中的其余行应该类似地重写。

您的代码的另一个问题是，您在为每个球重新加载blue_ball.bmp图像时，这个问题更多地是性能问题而不是正确性问题。通过仅加载一次实例位图会更好，然后让每个球都引用那个实例，而不是每次重新加载它。

Answer 5

假设我理解你要做的事情，那么下面的事情（未经测试）会更好：

#include <assert.h>

void add_balls(int *num_balls, ball **myballs){
    int n = ++*num_balls;
    ball *pb = realloc(*myballs, n * sizeof(ball));

    /* fail loudly and early on lack of memory. */
    assert(pb); 
    *myballs = pb;

    /* note the pre-decrement of n here to make obvious the common n-1 */
    pb[--n]->x =  rand() % 640;
    pb[n]->y = rand() % 480;
    pb[n]->vector_x = rand() % 10;
    pb[n]->vector_y = rand() % 10;
    pb[n]->image = load_bitmap("blue_ball.bmp", NULL); 
 }

虽然可以在最初编写的数组元素引用中使用足够的括号来使所有运算符优先级正确，但结果将基本上是人类无法读取的。事实上，->的从右到左的关联性与*的从左到右的关联性奇怪地混合，并且进一步被数组索引混淆。

您可能希望改进错误处理。特别是，如果内存不可用，根本就拒绝添加球可能是有意义的。在这种情况下，最好不要存储新指针（或新计数），直到知道realloc()有效。

从函数中重新分配

5 个答案: