size_t unsigned int (à partir de la fonction de l'API)

J'utilise l'Oracle de l'API pour accéder à une base de données et cette API a une fonction readBuffer(char * buffer, unsigned int size); à laquelle je ne peux faire aucune modifications.

J'ai une classe qui utilise cette API et la signature de mon heure actuelle, la fonction prend un std::string et un unsigned int pour la taille, le problème est que lorsque je passe std::string.size() à la taille de l'argument de ma fonction, je reçois un avertissement de mon compilateur que la conversion du size_t à unsigned int pourrait entraîner la perte de données.

Je me demandais si il y a un de façon valable pour convertir le size_t à un unsigned int afin que je puisse le transmettre à mon API et ne pas avoir un avertissement du compilateur?

Je comprends le but de size_t et de la recherche sur google pour cette conversion tourne un grand nombre de résultats que dire "changer la fonction de prendre un size_t arg" mais je NE peut pas modifier la signature de mon API dans ce cas.

Des suggestions?

  • size_t est en fait rien d'autre qu'un usigned de type int. Le problème est que la longueur de size_t n'est pas exactement défini, si votre système définit pour avoir plus de bits qu'un "normal" unsigned int, que vous ne pouvez rien faire pour éviter une éventuelle perte de données. L'avertissement apparaissent également lors de la coulée de façon explicite?
InformationsquelleAutor Tony The Lion | 2011-04-19
  1. 17

    Oui, écrire une fonction d'aide qui permettra de vérifier si une telle conversion est valide et de lever une exception dans le cas contraire. Quelque chose comme:

    unsigned int convert( size_t what )
{
    if( what > UINT_MAX ) {
       throw SomeReasonableException();
    }
    return static_cast<unsigned int>( what );
}
    • Oui, j'aime cette idée. En pratique, il est peu probable que la taille d'une chaîne est au-delà de 32bits (4 GO), mais c'est une belle pratique.
    • boost::numeric_cast ne c'est plus ou moins.
    • Excellente solution, merci!
    InformationsquelleAutor sharptooth
  2. 5

    Bien, faire un static_cast<unsigned int>(mystring.size()).

    La raison en est que std::size_t est généralement pointeur de taille, mais il y a 64 bits plates-formes sur lesquelles un int est toujours de 32 bits. Dans ce cas, la seule raison pour la perte de données serait si la chaîne en question avait une longueur de plus de 2^32 octets.

    Si vous savez que cela n'arrivera pas, mettre un assert quelque part pour attraper ce cas et static_cast le compilateur de silence.

    InformationsquelleAutor Alexander Gessler
  3. 4
    static_cast<unsigned int>(str.size());

    Si vous voulez être paranoïaque:

    if (static_cast<unsigned int>(str.size()) != str.size()) 
  throw ...
    InformationsquelleAutor Erik
  4. 1

    Vous pouvez forcer la conversion à l'aide de la 

    static_cast<unsigned int>(your_variable)

    construire. Bien sûr, la bonne façon serait de l'API pour accepter size_t...

    InformationsquelleAutor Diego Sevilla
  5. 1

    Le risque ici est que size_t pourrait être plus grand que (unsigned) int, et donc vous ne pouvez pas convertir en toute sécurité si c'est le cas.

    Par exemple, il est concevable que int est de 32 bits, alors que size_t est de 64 bits. Je ne sais pas ce système/configuration haut de ma tête, mais il pourrait se produire.

    Pour la plupart des "raisonnable" des systèmes, les deux seront au moins 32 bits, et un seul de 4 GO de chaîne est encore (peut-être) peu probable de se produire.

    Alors vous pourriez jeter, qui serait valable, mais il ne serait pas "sûre" pour tous les systèmes possibles et coin affaires.

    • "Je ne sais pas ce système/configuration haut de ma tête" - Windows 64 bits, 64 bits de linux.
    InformationsquelleAutor unwind