在“{”标记之前应使用“:”、“,”、“;”、“}”或“__attribute__”

Question

Can't find a mistake that causes the error in the title. Have been seeking for it for an hour, would be glad if someone helped me find the bug. I see no missing, and; or what-so-ever:( There is really not much need to add comments about the code purpose, just an annoying syntax error. I'm pretty much new with C, therefore the mistake might be obvious, however I have absolutely no clue concerning this part of the code and why it refuses to compile with gcc, but works fine with compiler integrated into CLion. I thought that CLion basically used the gcc, but none the less it is not what really important to me. Hence I would be really thankful to the one, who could guide me through. Full error message: error: expected ':', ',', ';', '}' or ' attribute ' before '{' token 92 | void initialize(int _height, int _width) {

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

// Definicji objektów na mapie (1)
#define ROCKFORD '@'
#define EMPTY ' '
#define DIRT '+'
#define HILL '#'
#define ROCK 'O'
#define DIAMOND '$'
#define EXIT 'X'

// Definicji kierunków ruchu (2)
#define UP 'w'
#define LEFT 'a'
#define DOWN 's'
#define RIGHT 'd'
#define NOTHING '0'

#define NEW_LINE (char) 10

typedef char object; // objekt na mapie, możliwe wartości są w definicji nr (1)
typedef char move; // kierunek ruchu, możliwe wartości są w definicji nr (2)

// *** Funkcjonal związany z typem move ***

// Wczytanie instrukcji ruchów oraz zwracanie false przy nowej linii
char readMove(move* command) {
    *command = (char) getchar();
    return (*command != NEW_LINE && *command != EOF);
}

// Wczytanie jednego symbolu w pustość aby pozbyć '\n'
void skipNewline() {
    getchar();
}

// Sprawdzenie, czy wczytany symbol nie jest końcem wejścia
bool isValid(move command) {
    return (command != EOF);
}

// Przetwarzanie kierunku ruchu na zmianę poziomowej współrzędnej
int verticalShift(move mv) {
    if (mv == UP || mv == DOWN)
        return (mv == UP ? -1 : 1);
    return 0;
}

// Przetwarzanie kierunku ruchu na zmianę pionowej współrzędnej
int horizontalShift(move mv) {
    if (mv == LEFT || mv == RIGHT)
        return (mv == LEFT ? -1 : 1);
    return 0;
}

// Struktura, reprezentująca współrzędną
typedef struct point {
    int x, y;
} point;

// *** Funkcjonal związany ze strukturą point ***

// Stworzenie współrzędnej
point makePoint(int x, int y) {
    point p;
    p.x = x, p.y = y;
    return p;
}

// Dodawanie odpowiednich współrzęd do siebie
point addPoints(point p1, point p2) {
    return makePoint(p1.x + p2.x, p1.y + p2.y);
}

// Sprawdzenie równości pomiędzy dwoma współrzędnymi
bool samePoints(point p1, point p2) {
    return (p1.x == p2.x && p1.y == p2.y);
}

// Typ danych reprezentujący planszę
typedef struct board {
    int height; // wysokość planszy
    int width; // szerokość plansy
    int diamonds; // liczba diamentów na planszy
    point rf; // pozycja Rockfordu w tablicy field
    object** field; // mapa objektów planszy
    bool reachedExit; // true wtw, gdy Rockford opuścił planszę

    // Inicjalizacja planszy
    void initialize(int _height, int _width) {
        height = _height;
        width = _width;
        field = (object **) malloc(sizeof(object *) * (size_t) height);
        for (int i = 0; i < height; i++)
            field[i] = (object *) malloc(sizeof(object) * (size_t) width);
        diamonds = 0;
        reachedExit = false;
    }

    // Otrzymanie objektu na planszy o współrzędnej pos
    object get(point pos) {
        return field[pos.y][pos.x];
    }

    // Zamiana objektu na planszy o współrzędnej pos na val
    void set(point pos, object val) {
        field[pos.y][pos.x] = val;
    }

    // Pokazywanie objektu na planszy o współrzędnej pos
    void show(point pos) {
        putchar(samePoints(rf, pos) && !reachedExit ? ROCKFORD : get(pos));
    }

    // Stabilizowanie planszy
    void stabilize() {
        point pos;
        for (pos.y = height - 1; pos.y >= 0; pos.y--) {
            for (pos.x = width - 1; pos.x >= 0; pos.x--) {
                object cur = get(pos);
                if (cur == DIAMOND || cur == ROCK) {
                    int dy = 0;
                    while (this->get(pos) == EMPTY && !samePoints(rf, pos)) dy++;
                    set(pos, EMPTY);
                    set(makePoint(pos.y + dy, pos.x), cur);
                }
            }
        }
    }

    // Pokazywanie każdego objektu na planszy
    void showBoard() {
        printf("%d %d\n", height, width);
        point pos;
        for (pos.y = 0; pos.y < height; pos.y++) {
            for (pos.x = 0; pos.x < width; pos.x++)
                show(pos);
            printf("\n");
        }
    }

    // Oczyszczenie pamięci alokowanej dla planszy
    void clear() {
        for (int i = 0; i < height; i++)
            free(field[i]);
        free(field);
    }
} board;

Answer 1

The way to do OOP in C (at least one of them) is to:

0. Have structs as classes
1. Declare member functions (as normal functions) outside the struct
2. Member functions should have a prefix that identifies what class it belongs to
3. Member functions should take as first parameter the object they are meant to be applied to.

Points 4,5,6 etc deals with multiple inheritance and virtual methods, I am not going to go into this now.

So as example:

struct board {
    int height;
    int width;
    int diamonds;
    point rf;
    /*
      This is not a good way to declare a 2d array, but fixing
      that is outside the scope of this answer
     */  
    object** field;
    bool reachedExit;
};

// Inicjalizacja planszy
void board_initialize(struct board *b, int height, int width) {
    b->height = height;
    b->width = width;

    /* TODO: Malloc needs error checking */
    b->field = malloc(sizeof(*b->field) * (size_t) height);
    for (int i = 0; i < height; i++)
        b->field[i] = malloc(sizeof(*b->field[i]) * (size_t) width);
    b->diamonds = 0;
    b->reachedExit = false;
}

/*
  `*b` is `const` since we don't intend to modify whatever `b` 
  points at
*/  
object board_get(const struct board *b, point pos) {
    return b->field[pos.y][pos.x];
}

void board_clear(struct board *b) {
    for (int i = 0; i < b->height; i++)
        free(b->field[i]);
    free(b->field);
}

Rest of methods are left out as exercise to the reader.

Constructors can be implemented as either returning a struct as value, or returning a pointer to malloc -ed memory:

struct board board_create(int h, int w)
{
   struct board b;
   board_initialize(&b, h, w);
   return b;
}

struct board *board_alloc(int h, int w)
{
   struct board *b = malloc(sizeof(*b));
   if (b)
      board_initialize(b, h, w);
   return b;
}

/* `board_malloc` also needs `board_free` */
void board_free(struct board *b)
{
   board_clear(b);
   free(b);
}

Example on how to use this:

struct board b1 = board_create(w, h);
object o1 = board_get(&b1, pos);
board_clear(&b1);

/*****************************/

struct board *b2 = board_alloc(w, h);
if (!b2)
  {
     perror("Allocation failed");
     exit(EXIT_FAILURE);
  }
object o2 = board_get(b2, pos);
board_free(b2);

Personally I prefer board_create / board_clear to board_malloc / board_free . I am of the opinion that the owner of a struct board should decide how and where its memory is allocated and stored. But this is a matter of style.

Naturally you could also bite the bullet and learn c++. In that case you should get rid of malloc / free and use container classes. Or use smart pointers in those rare cases where there is no fitting container class.

Total disclaimer: Any bugs in original code are left as is, and there may be some additional new, minor ones. Free work doesn't come with warranties.

Answer 2

I don't understand why you have functions declared inside a struct. You should define the struct and then declare your functions

typedef struct board {
    int height; // wysokość planszy
    int width; // szerokość plansy
    int diamonds; // liczba diamentów na planszy
    point rf; // pozycja Rockfordu w tablicy field
    object** field; // mapa objektów planszy
    bool reachedExit; // true wtw, gdy Rockford opuścił planszę
} board;

/* void initialize */

/* void get  */

...

Also, I would personally put the struct at the start, just after the various define . It doesn't change anything tho.