C++ STL carte typedef erreurs

Je suis vraiment très méchant problème avec un code que j'ai écrit. J'ai trouvé quelqu'un d'autre qui avait le même problème sur stackoverflow et j'ai essayé les solutions, mais aucune n'a fonctionné pour moi.

Je typedef plusieurs types STL que je l'utilise et aucun des autres ont tout problème, sauf quand j'essaie de typedef une carte.
Je reçois un "un_fichier.h:83: erreur: attendu initialiseur avant '<' token" erreur lors de l', y compris l'en-tête dans un programme de test.

Voici la partie importante de l'en-tête(un_fichier.h):

#ifndef SOME_FILE_H
#define SOME_FILE_H
//some syntax-correct enums+class prototypes
typedef std::string str;
typedef std::vector<Column> col_vec;
typedef col_vec::iterator col_vec_i;
typedef std::vector<Row> row_vec;
typedef row_vec::iterator row_vec_i;
typedef std::vector<str> str_vec;
typedef str_vec::iterator str_vec_i;
typedef std::vector<Object> obj_vec;
typedef obj_vec::iterator obj_vec_i;
typedef std::map<Column, Object> col_obj_map; //error occurs on this line
typedef std::pair<Column, Object> col_obj_pair;

L'inclut dans some_file.cpp sont:

#include <utility>
#include <map>
#include <vector>
#include <iostream>
#include <string>
#include <stdio.h>
#include <cc++/file.h>
#include "some_file.h"

Le fichier de test simplement la chaîne, vecteur, et mon fichier dans l'ordre. Il dispose d'une méthode principale qui fait juste un bonjour à tout le monde genre de chose.

Le plus drôle, c'est que j'ai rapidement jeté basé sur un modèle de classe pour voir où était le problème (en remplacement de la "std::map<Column..." avec "hello<Column...") et cela a fonctionné sans problème.

J'ai déjà créé la surcharge de l'opérateur requis par la carte si vous utilisez une classe sans " < ' opérateur.

Quel message d'erreur avez-vous?
Je dirais que c'est un bon exemple de l'abus typedef.
Et je dirais qu'il est beaucoup plus facile d'écrire col_vec au lieu de std::vector<Colonne>. En va de même pour l'itérateur, col_vec_i signifie tellement pour moi plus que std::vector<Colonne>::iterator. Il peut être "abus", mais il rend les choses plus faciles pour moi.
Je suis d'accord avec vous r0ssar00. Les typedefs rendre les choses plus facile de taper, de lire et de comprendre. L'avantage n'est pas aussi évident dans cet exemple, mais si jamais vous avez à travailler avec une map<string, vector<paire<double Objet*> > >, vous apprécierez la clarté de typedefs.
c'est un méchant-en regardant la carte, merci les devs de C++ pour les typedefs

OriginalL'auteur user150113 | 2009-08-04

c++compiler-errors stl typedef

14

Vous obtenez ce problème, car le compilateur ne sait pas ce qu'est une carte. Il ne le sait pas parce que la carte d'en-tête n'a pas été encore comprises. Votre en-tête utilise la STL modèles: string, vecteur, carte, & paire. Cependant, il n'a pas les définir, ou de toute référence à l'endroit où ils sont définis. La raison de votre fichier de test barfs sur la carte et non pas sur la chaîne ou le vecteur, c'est que vous incluez la chaîne de vecteur et les en-têtes avant un_fichier.h, afin de chaîne et vector sont définis, mais la carte n'est pas. Si vous incluez une carte d'en-tête, cela va fonctionner, mais il peut se plaindre de la paire (sauf si votre STL mise en œuvre comprend la paire dans la carte d'en-tête).

Généralement, la meilleure politique est de comprendre l'en-tête standard pour chaque type que vous utilisez dans votre propre en-tête. Donc un_fichier.h doit avoir, au moins, de ces en-têtes:
```
#include <string>
#include <map>
#include <utility> //header for pair
#include <vector>
```
L'inconvénient de cette approche est que le préprocesseur a charger chaque fichier à chaque fois et de passer par la #ifdef ... #endif conditionnelle de l'inclusion de traitement, donc si vous avez des milliers de fichiers, et des dizaines de inclut dans chaque fichier, ce qui pourrait augmenter votre temps de compilation de manière significative. Cependant, sur la plupart des projets, l'ajout d'aggravation d'avoir à gérer l'en-tête de l'inclusion manuellement n'est pas la peine de le minuscule gain en temps de compilation.
C'est pourquoi Scott Meyers Efficace STL livre a "Toujours #inclure le bon en-têtes" comme élément #48.

Facepalm! J'ai l'habitude d'inclure la STL trucs dans le programme, pas l'en-tête. Merci pour le lien.
Maintenant je sais que je ça en été, y compris STL trucs dans la tête.
Pour accélérer la compilation sur un gros projet, seulement mis inclut associées à ce fichier d'en-tête. Un fichier source correspondant aurez seulement besoin d'inclure le fichier d'en-tête et les fichiers supplémentaires qui se rapportent à la source de la mise en œuvre.
ce qui est vrai. Toutefois, vous serez toujours à la fin du traitement plusieurs fois le même fichier dans de nombreux cas. Par exemple, si A. h, B. h, ... Z. h tous les #include <vector>, et puis main.cpp comprend tous 26 les en-têtes de A à Z, alors le compilateur traite vecteur de 26 fois. Si vous prenez #include <vector> de les en-têtes et de les inclure dans main.cpp, alors il sera toujours compiler correctement, et seulement #include <vector> une fois. Cependant, vous finissez par avoir à gérer manuellement l'inclusion des dépendances, de sorte qu'il est rarement la peine de le faire.
vous ne devriez pas faire ça comme ça. Utiliser les en-têtes précompilés à la place : ils peuvent donner un décuplement de la vitesse de compilation. Une grande page sur la façon de faire : cygnus-software.com/papers/precompiledheaders.html

OriginalL'auteur A. Levy
5

Est-il un #include <map> quelque part dans votre fichier d'en-tête?

Mettre en là pour au moins voir si cela fonctionne. Vous devriez faire de toute façon.

OriginalL'auteur GManNickG
5

Vous devez déplacer une partie de ceux inclut dans votre fichier d'en-tête. Ces le besoin d'être placé à l'avant de votre typedef consolidés.

c'est à dire
```
#include <map>
#include <string>
#include <map>
```
Sinon, rien d'autre, y compris un_fichier.h (telles que votre programme principal) ne savent pas ce qu'ils sont à moins qu'il place également ces comprend avant le #include "un_fichier.h" directive include dans votre programme principal fichier source. Si vous faites cela, le problème devrait disparaître.

Wow, ne peut pas croire que j'ai manqué ça! J'ai l'habitude d'inclure tous les STL trucs dans le programme principal, de toute façon, donc ce problème qui n'a jamais fait son apparition. Merci pour le tuyau.

OriginalL'auteur Matt
0

Comme plusieurs personnes l'ont souligné, le compilateur n'est pas de trouver la définition de la carte. Puisque vous semblez être, y compris la carte d'en-tête, il ya 2 autres causes possibles, que je pense:
1. Un autre fichier d'en-tête le nom de map est en cours de chargement au lieu de std carte d'en-tête. Je pense que c'est peu probable.
2. Un autre en-tête est #define avec carte à autre chose.
Une façon de le vérifier est d'obtenir votre compilateur pour générer le post-traitement de fichier, c'est à dire le fichier source après qu'il a été exécuté grâce à la C le pré-processeur, mais avant il a été compilé. Vous devriez alors être en mesure de trouver votre ligne incriminée et de voir si le type de carte a été remplacé par quelque chose d'autre. Vous devez également être en mesure de rechercher le fichier et de voir ce que l'en-tête de la #include opulled.

Comment vous générez le post-traitement de fichier compilateur est dépendante - vérifier la commande en ligne de drapeaux de la doc de votre compilateur.

Pour gcc: gcc -E pour voir le postprocessed fichier.

OriginalL'auteur jon-hanson

Vous devez vous connecter pour publier un commentaire.