#include <iostream>
#include <SDL/SDL.h>
SDL_Surface *back;
SDL_Surface *x;
SDL_Surface *o;
SDL_Surface *screen;
int cell[8];

int InitImages() {
  back = SDL_LoadBMP("Back.bmp");
  x = SDL_LoadBMP("x.bmp");
  o = SDL_LoadBMP("o.bmp");
  return 0;
}
int SDL_BlitSurface(SDL_Surface *src, SDL_Rect *srcrect, SDL_Surface *dst, SDL_Rect *dstrect);
void DrawIMG(SDL_Surface *img, int x, int y) {
  SDL_Rect dest;
  dest.x = x;
  dest.y = y;
  SDL_BlitSurface(img, NULL, screen, &dest);
}
void drawIMG(SDL_Surface *img, int x, int y, int w, int h, int x2, int y2) {
  SDL_Rect dest;
  dest.x = x;
  dest.y = y;
  SDL_Rect dest2;
  dest2.x = x2;
  dest2.y = y2;
  dest2.w = w;
  dest2.h = h;
  SDL_BlitSurface(img, &dest2, screen, &dest);
}
void checkcell(mousex, mousey) {
  if(mousex < 317 && mousey < 297)

void drawbg() {
  DrawIMG(back, 0, 0);
}
void drawx(int v, int z, int y, int x2, int y2) {
  if(cell[v] == 0) {
    cell[v] = 1;
    drawIMG(x, z, y, 155, 147, x2, y2);
  }
  else
    std::cout<<"Cannot put x there."<<std::endl;
}
void drawo(int v, int x, int y, int x2, int y2) {
  if(cell[v] == 0) {
    drawIMG(o, x, y, 155, 147, x2, y2);
    cell[v] = 1;
  }
  else
    std::cout<<"Cannot put o there."<<std::endl;
}

int main(int argc, char* argv[]) {
  if(SDL_Init(SDL_INIT_AUDIO | SDL_INIT_VIDEO)<0) {
    std::cout<<"Unable to init SDL."<<std::endl;
    SDL_GetError();
  }
  InitImages();
  drawbg();
  int done=0;
  while(done == 0)
  {
    SDL_Event event;
    while ( SDL_PollEvent(&event) )
    {
      if ( event.type == SDL_QUIT )  {  done = 1;  }

      if ( event.type == SDL_KEYDOWN )
      {
        if ( event.key.keysym.sym == SDLK_ESCAPE ) { done = 1; }
      }
    }
  }
  return 0;
}

#include <iostream>#include <SDL/SDL.h>class cell {  private:    enum cellStatus {EMPTY, HASX, HASO};    bool cannotGoThere;  public:    void checkStatus(cellStatus status) {      switch (status) {        case EMPTY:          cannotGoThere = false;        case HASX:          cannotGoThere = true;        case HASO:          cannotGoThere = true;        }      }    void setStatusX(int x, int y) {      cellStatus cell[x][y] = HASX;    }    void setStatusO(int x, int y) {      cellStatus cell[x][y] = HASO;    }    void alreadyThere() {      std::cout<<"There is already a piece there."<<std::endl;    }  }class board : public cell {  private:    int cell[3][3];  public:    void placeX(int x, int y) {      void checkStatus(cell[x][y]);      if(cannotGoThere == false) {        setStatusX(x, y);      }      else        alreadyThere();    }    void placeO(int x, int y) {      void checkStatus(cell[x][y]);      if(cannotGoThere == false) {        setStatusO(x, y);      }      else        alreadyThere();    }  }

#include <iostream>#include <SDL/SDL.h>class cell {  private:    //very good, you seem to be using enums appropriately    enum cellStatus {EMPTY, HASX, HASO};       //hmm.. this jumps out to me as odd...perhaps you named this wrong? why would a board cell have a "cannotGoThere"? perhaps cell_taken or cell_used or cannotGoHere would be a better name?    bool cannotGoThere;  public:    //ok, this is pretty strange.. you have something thats called "checkX". usually when something is checking something, it will return a value saying the status. but your function doesnt return anything. how does it tell people the status of the cell?    void checkStatus(cellStatus status) {      switch (status) {        case EMPTY:          cannotGoThere = false;        case HASX:          cannotGoThere = true;        case HASO:          cannotGoThere = true;        }      }        void setStatusX(int x, int y) {           //here you are defining an array called cell[][].      //i just woke up, but im not even sure why this compiles       //instead it should look like cell[x][y] = HASX.      cellStatus cell[x][y] = HASX;    }    void setStatusO(int x, int y) {      cellStatus cell[x][y] = HASO;    }    //you might want to rename this function to make it more clear what it does. in the other part of your code it gets confusing    // PrintAlreadyThere() might be a better idea.    void alreadyThere() {      std::cout<<"There is already a piece there."<<std::endl;    }  }//ok. why is board inheriting from cell? this is all wrong. when using inheritence, you have to think to yourself. "Is an child a parent?". e.g., having Dog inherit from Animal. Is a dog an animal? how about in your case. is a board a cell? no, a board HAS a cell. hasA relationships are good for "composition". composition means putting a member inside of a class, instead of inheriting from that class.class board : public cell {  private:    int cell[3][3];  public:    void placeX(int x, int y) {            //what is this here now? why is void written out here? what you have here is a function declaration. you are not calling a function here. if you want to call the function, call checkStatus(cell[x][y]);      void checkStatus(cell[x][y]);      if(cannotGoThere == false) {        setStatusX(x, y);      }      else        alreadyThere();    }    void placeO(int x, int y) {      void checkStatus(cell[x][y]);      if(cannotGoThere == false) {        setStatusO(x, y);      }      else        alreadyThere();    }  }

#include <iostream>#include <SDL/SDL.h>class cell {  public:    enum cellStatus {EMPTY, HASX, HASO};         //a cell starts off as EMPTY    cell(): status(EMPTY) {}    cellStatus status;};class board {  private:    cell board[3][3];  public:    cellStatus checkStatus(int x, int y) {         return board[x][y].status;        }    void setStatusX(int x, int y) {      board[x][y].status = HASX;    }    void setStatusO(int x, int y) {      board[x][y].status = HASO;    }    void PrintalreadyThere() {      std::cout<<"There is already a piece there."<<std::endl;    }    void placeX(int x, int y) {      if(checkStatus(cell[x][y]) != EMPTY)          setStatusX(x,y);      else         PrintAlreadyTaken();    }    void placeO(int x, int y) {      if(checkStatus(x,y) != EMPTY)        setStatusO(x, y);            else        PrintAlreadyThere();    }  }

#include <iostream>class cell {  public:    enum cellStatus {HASX, HASO, EMPTY};    cell(): status(EMPTY) {};    cellStatus status;  };class board {  private:    cell cells[3][3];  public:    int checkStatus(int x, int y) {      return cells[x][y].status;    }    void printCannotPlace() {      std::cout<<"Cannot place there."<<std::endl;    }    void setStatusX(int x, int y) {      cells[x][y].status = HASX;      }    void setStatusO(int x, int y) {      cells[x][y].status = HASO;      }    void placeX(int x, int y) {      if(cells[x][y].status == EMPTY)        setStatusX(x, y);      else        printCannotPlace();      }    void placeO(int x, int y) {      if(cells[x][y].status == EMPTY)        setStatusO(x, y);      else        printCannotPlace();      }  };int main() {}