ich suche nach einer möglichkeit eine Array von Bytes zu vergleichen.

Die erste möglichkeit die ich suche wäre, zu prüfen ob in einer Array aus Bytes eine bestimmte Byte reihenfolge forhanden ist.
ähnlich der funktion StrCSpnI bzw der CString::Find funktion.

die zweite möglichkeit die ich suche wäre Bytes zu vergleichen ob in einer Byte Array genau das gleiche steht wie in einer andere
Byte Array. ähnlich der funktion StrCmpI == funzt ja hier nicht

kann mir da jemand weiterhelfen

mfg

ByteArray

Für ersteres könntest du std::find_if benutzen

aber mit find_if komm ich noch nicht so klar.

nehmen wir mal an ich haben einen Text als ByteArray vor mir liegen & suche in der ByteArray nach einem Namen zb (Marcus)
der ja auch eine ByteArray ist. So wie ich find_if versteh vergleicht es ja nur die einzelnen listenelemente.
somit müßte ich doch auch erst einmal jedes einzelne Byte aus der ByteArray in diese Liste packen und dann vergleichen.

wobei mir dann noch nicht ganz klar ist wie ich den Namen finden soll.

...
Die erste möglichkeit die ich suche wäre, zu prüfen ob in einer Array aus Bytes eine bestimmte Byte reihenfolge forhanden ist.
...
ByteArray

Das kannst du auch mit memcmp() erledigen - musste mal richtig durchdenken.

mfg

@gerie
um das nur mit memcmp() zu erledigen, fehlt mir das verständniss, das in einen kurzen Algorithmus zu packen, der das dann auch findet was ich such.
ansonsten würde mir eben nur einfallen memcmp() in eine Forschleife zu packen. Da es aber riesige datenmengen sind und ich etwas
ähnliches schon bewerkstelligt habe (forschleife die ByteArray Byte weise durchsucht), dies ewig lange dauert, fällt diese option flach.

An was hast du gedacht? wie würdest du es lösen?
bzw. jeder andere auch

hmmm,
also null terminiert ist die ByteArray nicht. hab es allerdings bei beiden (der zu durchsuchenden & der gesuchgten ByteArray) mit
ByteArray+='\0';
versucht, nur findet er dann nichts.

Wie genau ist denn "ByteArray" definiert?

Wie genau ist denn "ByteArray" definiert?

versteh jetzt nicht was du damit meinst

evtl das?

BYTE *byArray = new BYTE[Dateigröße+1];

Angenommen, Dein Array benötigt 100 bytes. Dann machst Du stattdessen:

BYTE *pB = new BYTE[100+1];
//Code zum Einlesen des Arrays
pB[100] = 0;

Angenommen, Du suchst jetzt nach dem Muster {0x12,0x13,0x14,0x15}:

BYTE pBSearch[] =  {0x12,0x13,0x14,0x15, 0x00};

Jetzt sind beide Arrays NULL-terminiert und Du kannst strstr anwenden:

BYTE *pGefunden = (BYTE*) strstr((char*)pB, (const char*)pBSearch);

wenn pGefunden != NULL dann gabs eine Übereinstimmung, nämlich genau bei pGefunden.
BYTE ist nun mal nichts anderes als ein unsigned char (Integer Wert 0 -> 255)

kurz knackig und extrem schnell.

BYTE *FindByte(BYTE *byDestination, DWORD dl, BYTE *bySource, DWORD sl) 
{	/**********************************************************************************************
										FIND BYTE
				Sucht in der Übergebenen Ziel Array nach einer Bezugs Array

			- byDestination Zeil Array in der gesucht wird
			- dl länge/größe der Zeil Array
			- bySource Bezugs Array die gesucht wird
			- sl länge/größe der Bezugs Array

	**********************************************************************************************/

	BYTE *p;

	for (p = byDestination; p <= (byDestination-sl+dl); p++)
	{
		if (memcmp(p, bySource, sl) == 0)
			return p; /* gefunden */
	}

	return NULL;
}

danke an alle die mir geholfen haben
mfg