Comment comparer la taille de vecteur avec un entier?

Je suis en utilisant le code suivant renvoie une erreur si la taille du vecteur (déclarée comme vector<int> vectorX) est différent de celui prévu.

vector<int> vectorX;
int intendedSize = 10;
//Some stuff here
if((int)(vectorX.size()) != (intendedSize)) {
    cout << "\n Error! mismatch between vectorX "<<vectorX.size()<<" and intendedSize "<<intendedSize;
    exit(1);
}

La cout déclaration montre de la même taille pour les deux. La comparaison n'est pas de les montrer à être égale.

De sortie est Error! mismatch between vectorX 10 and intendedSize 10

Où est l'erreur? Plus tôt, j'ai essayé (unsigned int)(intendedSize) mais qui aussi ont montré leur inégale.

quel a été le résultat?
Aussi, merci de nous montrer votre code.
Désolé, j'ai essayé de simplifier le code en le saisissant en question. Dans ce processus, j'ai fait de faute de frappe.
Écrire un court programme complet qui illustre le problème et puis, avant de l'afficher, de le compiler et de l'exécuter, pour vérifier qu'il a effectivement le même problème. Vous verrez que le programme de démonstration ne pas le problème que vous pensé qu'il a fait et l'problen est en fait quelque part d'autre que vous ne le pensiez. Afin de garder à la recherche pour elle.
merci pour la suggestion.

OriginalL'auteur user13107 | 2013-01-30

  1. 5

    Il vous manque ) dans le côté droit de l'instruction si

    if((int)(vectorX.size()) != (intendedSize)) {
                                          ^^^
}

    Mais remarque, c'est mauvais pour lancer la valeur de retour de std::vector::taille int. Vous perdez la moitié des possibilités de ce que la taille peut être(merci à chris).

    Vous devriez écrire:

    size_t intendedSize = 10; 
//OR unsign int intendedSize  = 10; 
if(vectorX.size() != intendedSize) {
}
    Merci. Vous dire que nous ne pouvons pas aller de size_t int mais nous pouvons aller de int à size_t?
    Vous perdez la moitié des possibilités de ce que la taille peut être.
    Merci. J'ai corrigé la faute de frappe. Même alors, les valeurs ne sont pas identiques. Ce que vous avez dit au sujet du casting, est-ce la raison derrière tout cela? En fait, je ne veux pas faire size_t intendedSize parce que cette variable est utilisée comme int à d'autres endroits.
    Parce que la taille ne peut jamais être positif, et int prend la moitié de la plage et de la place passe dans les négatifs. J'aurais autrement dit avant, mais il pourrait être beaucoup plus que la moitié si sizeof(size_t) > sizeof(int).
    ou utiliser unsigned int, pouvez-vous faire?

    OriginalL'auteur billz

  2. 17

    Je suis en train d'écrire cette réponse parce que les deux autres, y compris les acceptée, un, deux sont mauvais. Le type de std::vector's size() n'est pas unsigned int, ni size_t.

    Le type de la taille d'un std::vector<T> est std::vector<T>::size_type.

    Que c'est. Sur certaines architectures, et pour certains compilateurs, il pourrait être le même que size_t, dans certains autres, il pourrait ne pas. L'hypothèse qu'une variable de type size_t peut contenir les mêmes valeurs que l'une de type std::vector<T>::size_type peut échouer.

    Pour vérifier que votre vecteur a la bonne taille, vous pourriez faire quelque chose comme:

    if(vec.size() != static_cast<std::vector<int>::size_type>(expected_size)) {
    std::cerr << "Error!" << std::endl;
}
    Donc, vous êtes effectivement dire que vous devriez type for (std::vector<int>::size_type i=0; i<myVec.size(); ++i) {..} si vous souhaitez effectuer une itération sur un vecteur à l'aide des indices? La seule façon d'écrire ce danger que je vois, c'est l'utilisation de l'auto, ce qui était le comité de la pensée? Pourquoi ne pas simplement utiliser des int?

    OriginalL'auteur Alberto Santini

  3. 2

    Utiliser le size_t type de détenir la collecte des tailles:

    vector<int> vectorX;
size_t intendedSize = 10;
//Some stuff here
if(vectorX.size() != intendedSize) {
     ... 
}

    En fait, techniquement, vous devez utiliser vector<int>::size_type mais dans la pratique c'est toujours un typedef pour size_t

    Un int est généralement un entier signé de 32 bits.

    size_t est généralement un entier non signé entier de 64 bits (sur des architectures 64 bits) ou un entier 32 bits non signé (sur les architectures 32 bits).

    (À noter que la norme n'est pas d'imposer ces contraintes. L'ABI spécifie, par exemple le x86 et x86-64 ABI faire).

    OriginalL'auteur Andrew Tomazos