(non signé __int16 pour flotter) et flotter vers (unsigned __int16) typecast vs union en C++

Question

J'ai 3000 variables de type flottant (4 octets) et 2000 variables non signées __int16 (2 octets). Ces variables stockent les données de plc.

J'ai un tableau struct constant qui stocke les informations de chaque balise plc. Je souhaite regrouper toutes les variables ci-dessus (3000 float + 2000 ushort) sous la forme d'un seul tableau [5000]. Donc, je peux accéder à la valeur de la balise plc en fonction de l'index des balises.

J'ai trouvé deux solutions. Mais je ne sais pas lequel est correct à utiliser.

Solution 1: Déclarez la matrice flottante [5000] et la valeur d'accès en fonction de l'ID de balise plc.

float PLCDataArray1[5000] ; 

    //Get PLC data and assign to array 

    PLCDataArray1[0] = static_cast<float>(GetU16ValueFromPLC(addr)) ; 
    PLCDataArray1[1] = GetFloatValueFromPLC(addr) ; 
    . 
    . 
    PLCDataArray1[4999] = GetFloatValueFromPLC(addr) ; 

//To read back above data as String and show it on form. 
String GetPLCData(unsigned short tid) //tid is plc tag id 
{ 
    if(plcTags[tid] == 2) 
    { 
     return IntToStr(PLCDataArray1[tid]) ; 
    } 
    else 
    { 
     return FloatToStrF(PLCDataArray1[tid],ffFixed,6,2) ; 
    } 
} 

Solution 2:

union uFltOrUS16 
{ 
    unsigned __int16 usVal; 
    float   fltVal; 
}; 
uFltOrUS16 PLCDataArray2[5000] ; 

//Get PLC data and assign to array 
    PLCDataArray2[0].usVal  = GetU16ValueFromPLC(addr) ; 
    PLCDataArray2[1].fltVal = GetFloatValueFromPLC(addr) ; 
    . 
    . 
    PLCDataArray2[4999].fltVal = GetFloatValueFromPLC(addr) ; 

//To read back above data as String and show it on form. 
String GetPLCData(unsigned short tid) //tid is plc tag id 
{ 
    if(plcTags[tid] == 2) 
    { 
     return IntToStr(PLCDataArray2[tid].usval) ; 
    } 
    else 
    { 
     return FloatToStrF(PLCDataArray2[tid].fltval,ffFixed,6,2) ; 
    } 
} 

Pourriez-vous s'il vous plaît me suggérer quel type de solution ci-dessus est préférable d'utiliser pour mon problème? Si les deux ci-dessus ne sont pas bons à utiliser, veuillez me suggérer une meilleure idée à mettre en œuvre.

Merci.

Answer 1

Qu'est-ce que vous essayez de faire avec le union est appelé Type Punning, et est un comportement non défini en C++: https://stackoverflow.com/a/11996970/2642059

Parce que les syndicats sont souvent victimes d'abus parce du type à base vitesse offerte par union Punning donc la plupart C++ compilateurs faire soutenir un tel comportement. En bref, si vous avez l'intention d'écrire en mode portable c++ conforme à la norme, vous devez utiliser Solution 1; Cependant, en fonction de votre compilateur, vous pouvez trouver Solution 2 pour être une solution plus rapide sur votre compilateur.