1

我有一个名为 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()
4

5 回答 5

4

在你修改的add_balls函数中你增加了指针num_balls，你实际上想要增加指针的内容，(*num_balls)++；

于 2009-04-26T20:00:08.430 回答
3

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

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

于 2009-04-26T23:04:05.240 回答
3 
*myballs[*num_balls-1]->x

这取消引用了太多次 - myballs 是一个指针数组（或者换句话说，指向指针数组的第一个元素的指针） - 只是失去 myballs 前面的星号，现在你会得到指针 from您可以访问该结构（或者，将 -> 转换为 .）。符号 -> 是您从指向该结构的指针访问结构成员的简写，而不是从指向该结构的取消引用指针访问。

myballs[*num_balls-1]->x

或者

(*myballs[*num_balls-1]).x
于 2009-04-26T19:10:40.390 回答
3

您的原始代码非常接近正确。第一个问题比较容易解决。线

num_balls++;

应该

(*num_balls)++;

您正在增加指向的位置num_balls，而不是增加它指向的值。当你后来取消引用它时，它指向了其他一些内存——在这个特定的使用场景中，它可能指向堆栈中的下一个局部变量main()，即变量bg。

您的另一个问题是操作顺序问题。数组索引比取消引用具有更高的运算符优先级，因此该行

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

相当于

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

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

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

这就是你想要的，即取消引用指针以获取指向原始数组的指针，获取你想要的元素，并分配给成员变量x. 中的其余行add_ball()应类似地重写。

您的代码的另一个问题是性能问题而不是正确性问题，那就是您正在blue_ball.bmp为每个球重新加载图像。最好通过只加载一次位图来实例化位图，然后让每个球都引用该实例，而不是每次都重新加载它。

于 2009-04-27T01:20:15.010 回答
2

假设我了解您要执行的操作，则以下内容（未经测试）会更好：

#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()知道它已经工作。

于 2009-04-26T23:33:52.423 回答