C'est ma première question :)
J'ai un fichier de pile, et je l'ai ouvert comme indiqué ci-dessous; p> alors, je souhaite tenir 2 octets Données dans UNSIGNÉ INT HOLD; P> unsigned int hold;
in . read((char*)(&hold), 2);
5 Réponses :
_cast code> et trouver n'importe quel cas de C ++. La recherche de moules de style C est beaucoup plus difficile. Li>
- Deuxièmement - Si vous utilisez C ++ CASTS, vous devez choisir le bon. Dans votre cas, il est
reterpret_cast code>.
La coulée de style C fait tout. Li>
ul>
Vous pouvez également consulter ici: http://www.cplusplus.com/doc/tatudial / Typecasting / pour les différences des différentes counts C ++. Je recommande vivement seulement d'utiliser des moulages C ++. De cette façon, vous pouvez facilement trouver et les vérifier plus tard et vous êtes obligé de penser à ce que vous faites réellement là-bas. Cela améliore la qualité du code! P>
Si vous souhaitez toujours obtenir cela, vous pouvez utiliser static_cast code> est une distribution plus sûre que la coulée de style C implicite. Si vous essayez de jeter une entité qui n'est pas compatible avec une autre, alors
static_cast code> vous donne une erreur de temps de compilation différente de la distribution de style C implicite. P>
static_cast code> vous donne une erreur ici car ce que vous essayez de dire est de prendre un
int code> et essayez de l'adapter dans un
char code>, ce qui n'est pas possible.
int code> a besoin de plus de mémoire que ce que
Char code> occupe et la conversion ne peut pas être effectuée de manière sûre. P>
REINERPRET_CAST CODE>, il vous permet de taper deux types de données complètement différents, mais ce n'est pas sûr.
La seule garantie que vous obtenez avec réinterpret_cast code> est que si vous lancez le résultat vers le type d'origine, vous obtiendrez la même valeur, mais aucune autre garantie de sécurité. P>
+1 Pour l'explication, mais je mentionnerais Reterpret_cast Code> ici.
Vous auriez dû utiliser La différence est que, dans C ++, vous avez différents types de mises: p>
Le code de style C reterpret_cast
static_cast
int code> et
long code> ou entre
vide * code> et n'importe quel pointeur, mais
non signé INT * < / code> à
char * code> n'est pas "SAFE" et vous ne pouvez donc pas le faire avec
static_cast code>. p>
static_cast code> qui concerne les conversions "sûres"; p> li>
reterpret_cast code> qui est destiné aux conversions "dangereuses"; p> li>
const_cast code> qui est destiné à supprimer un attribut
const code>; p> li>
dynamic_cast code> qui est destiné à la sous-section (casting d'un pointeur / référence d'une superclasse à une sous-classe). P> li>
ul>
(char *) x code> peut signifier tous ces éléments ci-dessus, il n'est donc pas aussi clair que la C ++ moulage. En outre, il est facile à grep pour une distribution de style C ++ (juste Grep pour
_cast code>), mais il est assez difficile de rechercher toutes les couts de style C. P>
const_cast code> est pas b> uniquement pour casting
const code> mais aussi pour le moins communément connu / utilisé
volatile code> aussi.
@Andreabergia: Notez que const_cast code> peut aussi ajouter i>
const code> et
volatile code> qualificatifs. (Pas qu'il y ait de nombreuses situations où cela serait utile, bien sûr.)
Une coulée de style C ne signifie jamais la même chose que dynamic_cast code>. (Sauf dans ces cas où
static_cast code> et
dynamic_cast > faites la même chose qu'une conversion implicite.) Et
static_cast code> n'est pas toujours "sûr": Par exemple, il peut être jeté de la base à une référence / pointe dérivée lorsque l'objet n'est pas réellement dérivé.
Le Dans ce cas, bien sûr, vous lisez des données brutes et vous réclamez que c'est un
static_cast code> est illégal ici; Vous coulez entre sans rapport
Types de pointeur. La solution pour le faire compiler serait d'utiliser
Reterpret_cast Code> (qui est ce que
(char *) code> se résout dans ce cas).
Qui, bien sûr, vous dit que le code n'est pas portable, et en fait,
Sauf si vous faites un travail de niveau très bas, il ne fonctionnera probablement pas
correctement dans tous les cas. p>
non signé INT code>. Ce que ce n'est pas; les entrées de lecture sont des données brutes que vous
toujours à convertir manuellement à tout ce dont vous avez besoin, selon le
format utilisé lors de l'écriture du fichier. (Il n'y a pas de telle chose que
données non formatées. Juste des données avec un sans papiers, non spécifiés ou
format inconnu. L'entrée "non formatée" et la sortie dans
iostream sont conçus pour lire et écrire des tampons
char code> que vous formatez
manuellement. Le besoin de
reterpret_cast code> Voici un avertissement définitif
que quelque chose ne va pas avec votre code. (Il y a des exceptions, de
Bien sûr, mais ils sont rares entre.) p>
Vous obtiendrez généralement ces erreurs lors de l'E / S du fichier binaire en utilisant IFSTREAM ou ESTStream ou FRStream. Le problème est que ces flux ont des méthodes qui prennent La manière traditionnelle de faire consiste à utiliser l'ancien casting de style Je dirais, si vous faites des fichiers binaires d'E / S, vous savez déjà que les choses peuvent être portables ou non en fonction de la manière dont vous enregistrez le fichier dans un système d'exploitation et de lire dans un autre système d'exploitation. C'est toute une autre question, cependant, ne vous a pas fait peur par const char * code> tandis que ce que vous avez est un tableau d'un autre type. Vous souhaitez écrire votre tableau en tant que bits binaires dans le fichier. p>
(char *) code> qui dit fondamentalement que tout le pointeur que je le traite comme
(char *) code> . Les anciennes coulées de style sont découragées par Pedantic / Mode strict . Pour vous débarrasser de ces avertissements, l'équivalent C ++ 11 est
Reterpret_cast
Reterpret_cast
Dupliqué possible de Quelle est la différence entre static_cast < > et c style casting?
Tailleof (Unsigné Int) Code> est normalement supérieur à 2, vous aurez donc des octets initialisés et certains octets ininitialisés dans votre
Hold code>, ce qui n'est pas du tout utile.