मैं अपने छोटे गेम इंजन के लिए एक कस्टम बाइनरी फ़ाइल लिखना चाहता हूं। मैंने सी # के साथ काम किया और मुझे पता है कि इसे सी # में बिटकॉनवर्ट या कन्वर्ट के साथ कैसे किया जाए।

लेकिन कुछ कारणों से मुझे सी ++ में ऐसा करने की ज़रूरत है।

यहां मेरी डेटा संरचना है:

Mesh Position    point3(x,y,z)       type: float   size: 4bytes *3 = 12bytes
Mesh Options     point3(b1,b2,b3)    type: bool    size: 1byte  *3 = 3bytes
Mesh Scale       point3(x,y,z)       type: int     size: 4bytes *3 = 12bytes
Mesh Tag         single              type: string  size: 8bytes *1 = 8bytes

अब मेरे पास अहस्ताक्षरित वर्णों की एक सूची है:

vector<unsigned char> binary_data;

और मैं इसमें सिंगल बाइट्स जोड़ने के लिए पुश का उपयोग कर सकता हूं और अंत में इसे ऑफस्ट्रीम के साथ लिख सकता हूं:

ofstream fout;
fout.open("file.bin", ios::binary | ios::out);

vector<unsigned char> binary_data;

binary_data.push_back(0x66);
binary_data.push_back(0xFF); // bool : true
binary_data.push_back(0x00); // bool : false

fout.write((char*)binary_data.data(),binary_data.size());

fout.close();

मेरी समस्या

मुझे किसी भी प्रकार के फ्लोट, इंट, बूल, यूंट, डबल से बाइट सरणी के अपने मूल्यों को परिवर्तित करने और इसे मेरी वेक्टर सूची में जोड़ने की आवश्यकता है।

और फिर से उन्हें प्राप्त करें और उन्हें वापस मूल मूल्य में परिवर्तित करें।

ऑफसेट और बाइट आकार सभी ज्ञात हैं।

यहां एक उदाहरण दिया गया है: दृश्य में दो जाल हैं ..

  • पहले का पैमाना: बिंदु3(10,5,15)
  • दूसरे का पैमाना: बिंदु 3 (25,0,5)

अब मैं xyz प्राप्त करता हूं और उन्हें 4 बाइट्स में परिवर्तित करता हूं:

10 = > 00 00 00 0A
5 = > 00 00 00 05
15 = > 00 00 00 0F
25 = > 00 00 00 19
0 = > 00 00 00 00
5 = > 00 00 00 05

और मैं उन्हें binary_data सूची में जोड़ देता हूं।

मैं उन्हें बाइट ऐरे और बैक में कैसे बदल सकता हूं?

1
user11472260 30 जून 2019, 13:32

1 उत्तर

सबसे बढ़िया उत्तर

आप std::memcpy इस तरह इस्तेमाल कर सकते हैं:

#include <vector>
#include <cstring>

template<typename T>
void serialize(std::vector<char>& v, const T& obj){
    auto size = v.size();
    v.resize(size+sizeof(T));

    std::memcpy(&v[size], &obj, sizeof(T));
}

अक्रमांकन इसी तरह किया जा सकता है:

template<typename T>
void deserialize(const std::vector<char>& v, std::size_t offset, T& obj){      
     std::memcpy(&obj, &v[offset],sizeof(T));
}

कोई भी टाइप-कास्टिंग करने से पहले आपको सख्त अलियासिंग नियम से परिचित हो जाना चाहिए। .

1
Quimby 30 जून 2019, 13:44