C++ Java static final équivalent

Je suis à l'aide de C++ pour programmer un jeu d'échecs. Je veux créer deux attributs de classe le Conseil de classe: les LIGNES et les COLONNES. En Java, je voudrais déclarer en static final et tout fonctionne comme je veux. Comment je fais la même déclaration en C++? J'ai besoin d'accéder à ces attributs par "Conseil d'administration::les LIGNES" et "Conseil d'administration::les COLONNES" dans d'autres classes.

Ce que j'ai, c'est ce qui est en train de jeter des erreurs de compilation depuis les LIGNES et les COLONNES ne sont pas déclarées dans le cadre de la déclaration de m_TileMap. Est-il une bonne pratique pour le faire sans l'aide de #define déclaration?

class Board {
  Tile *m_TileMap[ROWS][COLUMNS];

public:
  static const int ROWS = 8;
  static const int COLUMNS = 8;

  Board(int m[ROWS][COLUMNS]);
}

Je suggère d'utiliser std::vector<int> à la place!

OriginalL'auteur Lucas Kreutz | 2013-05-17

c++const declaration static

2

déclarer votre m_TileMap après la déclaration de LIGNES et de COLONNES

par exemple
```
class Board {

public:
  static const int ROWS = 8;
  static const int COLUMNS = 8;

  Board(int m[ROWS][COLUMNS]);

private:
  Tile *m_TileMap[ROWS][COLUMNS];
};
```
La raison pour cela est parce que en C++, le compilateur ne pas lire avant. Donc, pour ROWS et COLUMNS pour être compris par le compilateur lorsque vous déclarez m_TileMap, ils doivent être déclarés avant.

Merci pour l'explication, c'est logique.

OriginalL'auteur Jimmy Lu
2

Vous pouvez réordonner les membres de la classe, de sorte que les LIGNES et les COLONNES sont déclarées avant d'être utilisées:
```
class Board {
public:
  static const int ROWS = 8;
  static const int COLUMNS = 8;

  Board(int m[ROWS][COLUMNS]);

private: 
  Tile *m_TileMap[ROWS][COLUMNS];
};
```
Merci!!!! Qui a travaillé...
Vous êtes les bienvenus. Et bienvenue sur StackOverflow. Vous pouvez upvote réponses que vous trouverez utiles en cliquant sur le triangle à gauche. (Ce qui est disponible en plus cochant la réponse la plus utile pour vous.)

OriginalL'auteur Andy Thomas

Essayez d'utiliser les énumérations suivantes

class Board {
public:
    enum {ROWS = 8};
    enum {COLUMNS = 8};

private:
    Tile *m_TileMap[ROWS][COLUMNS];

public:
    Board(int m[ROWS][COLUMNS]);
};

OriginalL'auteur Nikolay Viskov

1

ROWS et COLUMNS n'ont pas encore été déclarées lors de la définition de m_TileMap est analysée. Il suffit de déplacer ces définitions:
```
class Board {
  Tile *m_TileMap[ROWS][COLUMNS];

public:
  static const int ROWS = 8;
  static const int COLUMNS = 8;

  Board(int m[ROWS][COLUMNS]);
};
```
En aparté, si vous n'avez pas besoin de toujours prendre l'adresse de ROWS ou COLUMNS, une alternative serait d'utiliser un enum, comme ceci:
```
class Board {
public:
  enum { ROWS = 8, COLUMNS = 8};
  Tile *m_TileMap[ROWS][COLUMNS];


  Board(int m[ROWS][COLUMNS]);
};
```
Tout cela ayant été dit, ne serait pas que la vie sera tellement plus simple si vous venez d'utiliser vector?

Merci pour l'explication. Je vais utiliser un enum, je pense que c'est plutôt mieux. J'ai utilisé un tableau de cause, je pense qu'il sera plus facile à utiliser avec un algorithme minimax.

OriginalL'auteur John Dibling
0

Vous devez indiquer les tailles dans la définition de la classe:
static const int ROWS = 8;
etc.

Et ne pas oublier le ; après la définition de la classe!

OriginalL'auteur Bathsheba
0

Vous pouvez également utiliser #define qui est plus de style C, mais aussi plus performants que les énumérations. La raison pourquoi c'est le plus rapide, c'est que le compilateur remplace chaque occurrence de l'eg ROW avec le réel calue (8).
En outre, le compilateur Java remplace également static final-variables à l'effectif de byte code (qui peut parfois être un problème, voir ici: https://www.quora.com/What-is-the-syntax-for-declaring-a-static-final-class-variable )

Dans votre exemple, ce serait:
```
#define ROWS 8;
#define COLUMNS 8;
class Board {
public:
  Board(int m[ROWS][COLUMNS]);
private:
  Tile *m_TileMap[ROWS][COLUMNS];
};
```
Mais être conscient de la visibilité et de l'adresse de l'espace - vous ne devez pas mettre des définitions comme dans l'en-tête, parce que vous serait alors de forcer tout le monde.

Pour l'en-tête, ce serait préféré: disons que vous avez un fichier d'en-tête (conseil d'administration.h) dans laquelle vous spécifiez
```
class Board {
public:
  static const int ROWS = 8;
  static const int COLUMNS = 8;
  //...
};
```
Donc tout le monde y compris votre conseil d'administration.h peut utiliser Board::ROWS et Board::COLUMNS. (c'est un comportement intentionnel)
Voir cette réponse pour référence: https://bytes.com/topic/c/answers/454265-convert-static-final-java-c#post1738052

Une autre différence à noter est que ces makros non typées en comparaison à const, ce qui est tapé (de type int par exemple, lorsque la valeur définie n'en a pas). En outre, il y a aussi des constantes dynamiques, mais qui devrait être un peu trop hors sujet - lecture ici: https://en.wikipedia.org/wiki/Constant_(computer_programming)#Dynamiquement valued_constants
Mais aussi le définit en C/C++ peut faire beaucoup plus, voir ici par exemple: https://www.quora.com/What-is-are-the-alternative-s-of-define-in-java

Une autre chose un peu de prospective: la constante des chaînes C++ équivalent de Java static final String (première réponse)

OriginalL'auteur Cadoiz

Vous devez vous connecter pour publier un commentaire.