vector typeconvertierung char > struct

[Crack-wtf]

Hi Leute,

ich habe aktuell ein kleines "Problem".
Zwar habe ich schon einen Workaround, würde aber trotzdem gerne wissen ob/wie es trotzdem geht.

Ich habe einen vecor vom typ char.
Dieser enthält byte für byte eine bestimmte Datei.

Jetzt möchte ich daraus einen vectoren machen, der eine struct als typ hat.

Folgendes habe ich probiert:

struct PakBody
{
	unsigned char fileIndex;
	char filePath[132];
	int fileSize;
	int fileOffset;
};


std::vector<unsigned char> m_pakContent;
std::vector<PakBody> m_pakBodys(m_pakContent.begin(), m_pakContent.end());

Der Compiler beschwert sich mit folgendem Fehler

Error	1	error C2664: 'PakBody::PakBody(const PakBody &)' : cannot convert argument 1 from 'unsigned char' to 'const PakBody &'

Was mache ich falsch?

Ps: Mein "Workaround" ist ein resize von m_pakBodys + memcpy.

[Jeoni]

Du könntest für den Zugriff casten. Sähe dann so aus:

DoSomethingWith(reinterpret_cast<PakBody*>(&m_pakContent[0])[someIndex]);

Vorteil ist natürlich, dass nicht kopiert und kein neuer Speicher angefordert werden muss. Nachteil ist, dass das schnell nervig und unübersichtlich wird.
Kannst du nicht auf den std::vector<unsigned char> verzichten und direkt nur den struct vector nutzen? Ich denke, dass das die beste Möglichkeit wäre.
Oder musst du unbedingt kopieren, weil du beide vectors seperat benötigst?
Mit freundlichen Grüßen
Jeoni

[Terrat]

Les dich bitte in das Thema Vectoren ein.
Du könntest als erstes mal den Vector der die Struct enthãlt zu einen Vector machen der einfach nur Pointer beinhaltet. Das was du da vorhast ist schwachsinnig einen Vector eine Grundgröße zu geben, da Vectoren Dynamische Arrays sind.

struct PakBody
{
	unsigned char fileIndex;
	char filePath[132];
	int fileSize;
	int fileOffset;
};


std::vector<unsigned char> m_pakContent;
std::vector<PakBody*> m_pakBodys;

void AddShiat()
{
PakBody* pPakBody = new PakBody;
unsigned char pChar;
//hier beliebigen shiat in pPakBody setzen
//hier den char setzen
m_pakBodys.push_back(pPakBody);
m_pakContent.push_back(pChar);
}

Wundert euch net, gerade alles am Handy geschrieben.

[Crack-wtf]

Ich brauch aber die Bytes beieinander, weil ich diese verschlüssle/entschlüssle. (mit DES)
Mit pointern wäre das ziemlich umständlich bis garnicht möglich, weil ich immer 8byte Blöcke brauche.

Den wechsel von char -> struct habe ich deswegen gemacht, weil ich ja in 8byte blöcken entschlüssle und nach jedem durchlauf eine struct noch nicht voll ist.

Was ist ver/entschlüssle ist eine liste von dateien.

[MrSm!th]

Mit Pointern geht das eigentlich sehr gut. Ich würde von Anfang an die Daten in einen vector mit Structs einlesen und dann so zum Verschlüsseln vorgehen:

void Decrypt(char *buf, size_t bufsize);

Decrypt(reinterpret_cast<char *>(&vec[0]), vec.size());

vector ist eine generische Klasse. Die Dinger haben es so an sich, dass sie typsicher sind.

std::vector<PakBody> m_pakBodys(m_pakContent.begin(), m_pakContent.end());

Genau so eine Schweinerei wird dadurch verhindert. Du hast eine Liste von PakBodys und willst sie mit einer Liste von chars initialisieren. Dafür wird nun jedes Element von m_pakContent durchgegangen und in m_pakBodys gesteckt, was natürlich nicht klappt, da char nun mal nicht in PakBody konvertiert werden kann. Dein Workaround nutzt genau dieselbe Schweinerei, die mein Beispiel auch nutzt: durch Verwenden von Pointern und eines Casts umgeht man die Typprüfung und interpretiert die Daten, auf die gezeigt wird, neu. Du machst es halt per memcpy und erzeugst damit eine Kopie und ich würde es eher in-place machen.

[Crack-wtf]

Originally Posted by MrSm!th

Mit Pointern geht das eigentlich sehr gut. Ich würde von Anfang an die Daten in einen vector mit Structs einlesen und dann so zum Verschlüsseln vorgehen:

void Decrypt(char *buf, size_t bufsize);

Decrypt(reinterpret_cast<char *>(&vec[0]), vec.size());

vector ist eine generische Klasse. Die Dinger haben es so an sich, dass sie typsicher sind.

std::vector<PakBody> m_pakBodys(m_pakContent.begin(), m_pakContent.end());

Genau so eine Schweinerei wird dadurch verhindert. Du hast eine Liste von PakBodys und willst sie mit einer Liste von chars initialisieren. Dafür wird nun jedes Element von m_pakContent durchgegangen und in m_pakBodys gesteckt, was natürlich nicht klappt, da char nun mal nicht in PakBody konvertiert werden kann. Dein Workaround nutzt genau dieselbe Schweinerei, die mein Beispiel auch nutzt: durch Verwenden von Pointern und eines Casts umgeht man die Typprüfung und interpretiert die Daten, auf die gezeigt wird, neu. Du machst es halt per memcpy und erzeugst damit eine Kopie und ich würde es eher in-place machen.

Aber wie soll ich byteweise auf den structvector schreiben?
Das geht doch nicht oO

Oder bin ich zu doof dafür?
Kann ja nicht einfach ein Byte zu der struct casten.

[Padmak]

Na klar kannst du das - Vektoren sind genau deswegen so nützlich, weil ihr Inhalt byteweise ~in einem Block~ im Speicher liegt.
Oder verwirrt dich &vec[0]?
Damit bekommst du einen Pointer auf das erste Byte aus genau diesem Speicherblock und kannst damit tun und lassen was du willst - wie bei einem normalen C-Array

Padmak

[snow]

Warum eigentlich nicht vec.data() verwenden?

[Crack-wtf]

Dann muss ich doch aber immer manuell ein Resize machen.

Byte reservieren, byte schreiben, byte reservieren, byte schreiben.

Ich versuch aber mal was anderes.
Ich resize direkt meinen Structvector und loope per index durch &vec[i].
Ist zwar unsauber, aber wenns klappt o:

Mein Problem ist, wenn ich einen Vector mit dem typ "structxy" deklariere.
Dann kann ich ihm nicht sagen: "Schreibe folgendes BYTE."
Er würde ja nicht den index um 1 hochsetzen, sondern um die größe der struct.

[warfley]

Wie wäre es mit einer Union?

union Name {
  char chrArr[141]; //SizeOf(Record)
  YourRecord Rec; // Deine Struct
}

Der Vektorindex für die Chars ist dann ByteIndex Div SizeOf(Union) und der Char Array index ist dann ByteIndex Modulo SizeOf(Union). Und wenn du die Structs Brauchst ist es einfach Union.Rec.

Wenn es das ist was du meinst

PS: Warum nutzen so viele C Entwickler Chars statt Bytes? Ich versteh das einfach nicht

[MrSm!th]

Originally Posted by Crack-wtf

Dann muss ich doch aber immer manuell ein Resize machen.

Byte reservieren, byte schreiben, byte reservieren, byte schreiben.

Warum nicht einfach ein einziges mal .resize(), so wie in deinem Workaround?
Außerdem kannst du die Bytes einfach in ein ganz normales char Array einlesen, den Pointer zu einem PakBody-Pointer casten und mit diesem dann den vector initialisieren (Konstruktor mit first und last als Parameter).

ca. so:

const int max_pakbody_count = 42;
char buf[max_pakbody_count * sizeof(PakBody)];

//read stuff...

PakBody *pakbodyView = reinterpret_cast<PakBody *>(buf);
vector<PakBody> contents(pakbodyView, pakbodyView + max_pakbody_count - 1);

Ich versuch aber mal was anderes.
Ich resize direkt meinen Structvector und loope per index durch &vec[i].
Ist zwar unsauber, aber wenns klappt o:

Und dann?

Mein Problem ist, wenn ich einen Vector mit dem typ "structxy" deklariere.
Dann kann ich ihm nicht sagen: "Schreibe folgendes BYTE."
Er würde ja nicht den index um 1 hochsetzen, sondern um die größe der struct.

Doch, kannst du. Mit Pointer-Schweinerei. Genau für sowas ist die gut.

Originally Posted by warfley

Wie wäre es mit einer Union?

union Name {
  char chrArr[141]; //SizeOf(Record)
  YourRecord Rec; // Deine Struct
}

Der Vektorindex für die Chars ist dann ByteIndex Div SizeOf(Union) und der Char Array index ist dann ByteIndex Modulo SizeOf(Union). Und wenn du die Structs Brauchst ist es einfach Union.Rec.

Wenn es das ist was du meinst

PS: Warum nutzen so viele C Entwickler Chars statt Bytes? Ich versteh das einfach nicht

Dann doch lieber chrArr[sizeof(YourRecord)] und wozu noch händisch die Byte-Offsets der einzelnen Records berechnen, wenn man schon die union hat? vec[RecordIndex].Rec bzw. vec[RecordIndex].chrArr[ByteIndex] tut es doch.

[Crack-wtf]

Hat sich erledigt, danke an alle.
Kann geschlossen werden.

Ps: Habe es so geregelt, dass ich direkt auf meinen Vector entschlüsselt habe und statt erst in ein array zu schreiben, eben direkt darauf schreibe.