Er zijn 10 reacties in dit onderwerp

[Vic]

Ik heb ergens een C++ module gevonden die ik probeer te begrijpen maar ik ken eigenlijk te weinig van C++ en daarom zoek ik iemand die me een beetje zou willen helpen.
De code begint als volgt,

C Code:

byte mpbb[] =
{
	 65,  54,  19,  98, 168,  33, 110, 187,
	244,  22, 204,   4, 127, 100, 232,  93,
};

Klopt het dat er hier dus een array aangemaakt en opgevuld wordt?

Dan komen de volgende defines, welke ik niet goed snap.
C Code:

#define mpbbR   (mpbb)
#define mpbbS   (mpbb + 256)

Verder wordt er een functie als volgt gedefinifieerd,
C Code:

void Permute(PVOID pv, int cb, BOOL fPermute)

wat betekent die PVOID

en ten slotte worden nog de volgende vars aangemaakt
C Code:

   byte *		  pb	  = (byte *)pv;
   byte *		  pbTable   = fEncrypt ? mpbbR : mpbbI;
   const DWORD *   pdw	= (const DWORD *) pv;

ook dit begrijp ik niet ten volle

Dank bij voorbaat voor de hulp
Mvg, Vic

[pascalbianca]

Dat van.:

Quote

Dan komen de volgende defines, welke ik niet goed snap.
C Code:

#define mpbbR   (mpbb)
#define mpbbS   (mpbb + 256)

Kun je hier vinden.: http://blogs.msdn.co...e-decoding.aspx

Wat PVOID betekend.:
Dit is hetzelfde als.:
C Code:

void *pMemPhy

oftwel betekend dit...

It's a void pointer -- a pointer to a memory address with no information about the type of the value that it is pointing to. For this reason, you must cast the pointer to a type such as (char *)pMemPhy or (int *)pMemPhy before using the pointer so that the compiler knows how much memory it's working with (1 byte for a char, 4 bytes for an int, etc.)

[Vozzie]

Hallo,


* Klopt het dat er hier dus een array aangemaakt en opgevuld wordt?

Yep.



* Dan komen de volgende defines, welke ik niet goed snap.

Define is gewoon "tekst vervanging". Ook wel C macro's genoemd.

Stel als ik heb

C Code:

#define add(x,y)  x + y

Als ik ergens in mijn programma schrijf

C Code:

int z = add(1,2);

Maakt de compiler daarvan

C Code:

int z = 1 + 2;

* wat betekent die PVOID

PVOID is zoals pascal al aanhaalt een pointer. Een void pointer gebruikt men veel om te casten van/naar types zonder dat het type gekend is. Denk aan Boxing/Unboxing van een .Net Object.

Anders, bijvoorbeeld in C heeft de CreateThread functie als argument de start procedure. De start procedure heeft als signatuur "DWORD WINAPI ThreadProc(LPVOID lpVoid)". Nu kan je een pointer naar wat dan ook aan die functie doorgeven en binnen die functie terug casten naar het origineel.

C Code:

void SomeFunc(LPVOID lpVoid){
	int * p = (int*)lpVoid;
}

void Sample() {
	int i = 10;
	SomeFunc(&i);
}

Of stel je de volgende structure voor... Dan kan je daar verschillende types "objecten" in opslaan...

C Code:

struct MyDynamicObject {
	int objectType;
	void * lpObject;
};

(pointers zijn 32 bits op een 32 bit OS en zijn 64 bits op een 64 bit OS in 64 bit mode.)



* en ten slotte worden nog de volgende vars aangemaakt

Zie 1, 2, 3

1) C Code:

byte * pb = (byte *)pv;

pb is nu een byte pointer naar pv.

Je kan pb nu gebruiken als array
C Code:

pb[0] = 10;
pb[1] = 12;
byte z = pb[2];

Maar ook als pointer,...  Met de * operator verkrijg je de waarde waar de pointer naar wijst...
C Code:

*(pb+0) = 10;¨
*(pb+1) = 12;
byte z = *(pb+2);

(De code als array en als pointer doen precies hetzelfde!)

2) C Code:

byte * pbTable = fEncrypt ? mpbbR : mpbbI; 

Kan je lezen als volgt,...

C Code:

byte * pbTable;
if(fEncrypt){
	pbTable = mpbbR;
}else{
	pbTable = mpbbI;
}

3) C Code:

const DWORD * pdw = (const DWORD *) pv; 

Hetzelfde als een byte pointer maar een dword pointer. Dus in plaats van 1 bytes 4 bytes. Dat komt erop neer dat je bij pdw+1 niet 1 byte maar 4 bytes optelt. In C++ schuift hij de lengte van de waarde waar de pointer naar wijst op als je de pointer verhoogt...

const staat voor Constante, dus niet veranderbaar. Je kan de waarde waar de pointer naar wijst niet veranderen, maar wel lezen. En je kan de pointer verhogen,..

Kan: pdw = pdw+1;
Kan: DWORD x = *pdw;
Kan niet: *pdw = 100;


Voorbeeld programma - C Code:

#include "stdafx.h"
#include <windows.h>

int _tmain(int argc, _TCHAR* argv[])
{
	// a is a byte array (byte is a unsigned char)
	byte ab[] = {1,2,3};
	// p is a byte pointer, pointing to first element in array a
	byte * pb = ab;
	for(int i = 0; i < 3; i++){
		// add the value of *p to *p
		*pb += *pb;
		printf("Pointer: %d  Value: %d\n", pb, *pb);
		pb++;
	}

	printf("\n");
	
	// hetzelfde met integers...
	// let op de waarde van pointer
	int ai[] = {4,5,6};
	// p is a byte pointer, pointing to first element in array a
	int * pi = ai;
	for(int i = 0; i < 3; i++){
		// add the value of *pi to *pi
		ai[i] += *pi;
		printf("Pointer: %d  Value: %d\n", pi, *pi);
		pi++;
	}

	printf("\n");

	// pointers zijn bijvoorbeeld heel handig met een C string
	// s is een pointer naar een string
	char * s = "Hello";
	// zolang
	while(*s != 0){
		printf("%c\n", *s);
		s++;
	}

	printf("\n");

	DWORD adw[] = {10, 20};
	// const pointer die wijst naar array van dwords
	const DWORD * pdw = (const DWORD *)adw;
	// kan waarde waar pointer naar wijst lezen
	printf("%d\n", *pdw);
	// kan pointer naar een andere waarde laten wijzen
	pdw++;
	// kan andere waarde lezen met pointer
	printf("%d\n", *pdw);
	DWORD x = *pdw;
	// kan de waarde waar pointer naar wijst niet veranderen
	//*pdw = x;
	
	getchar();
	return 0;
}

Output (Merk op dat de byte pointer met 1 verhoogt en de int pointer met 4, een int is namelijk vier bytes) Code:

Pointer: 2751676  Value: 2
Pointer: 2751677  Value: 4
Pointer: 2751678  Value: 6

Pointer: 2751632  Value: 8
Pointer: 2751636  Value: 10
Pointer: 2751640  Value: 12

H
e
l
l
o

10
20

Groetjes

[Vic]

Thx voor de uitgebreide uitleg.
Nu heb ik heel lang geleden wel wat C geleerd en ken dus wel het principe van #Define en begrijp ik perfect jouw voor voorbeeld. Maar ik snap niet zo goed wat deze defines juist betekenen
Code:

#define mpbbR   (mpbb) 
#define mpbbS   (mpbb + 256) 

Mischien zoek ik te ver hoor, maar die eerste define mpbbR is net het zelfde als de array mpbb of wat? En die tweede dan?

Mvg, Vic

[Vozzie]

Hallo,

Overal waar er in je code staat "mpbbR" mag je dat vervangen door "mpbb".
En overal waar er in je code staat "mpbbS" mag je dat vervangen door "mpbb + 256"

dus  C Code:

LPVOID lpVoid = (LPVOID) mpbbR;

is hetzelfde als C Code:

LPVOID lpVoid = (LPVOID)mpbb;

EN

dus C Code:

LPVOID lpVoid = (LPVOID) mpbbS;

is hetzelfde als C Code:

LPVOID lpVoid = (LPVOID)(mpbb+256);

Volgens mij is mpbb een pointer,... mpbbR een synoniem voor die pointer en mpbbS een macro die wijst naar mpbb + 256(elementen)...

Je kan altijd rechts klikken op mpbb en dan "Go To Defenition" ofzo... Dan weet je wat mpbb precies is...

Groetjes

[Vic]

 Vozzie, on 19 april 2012 - 11:20, said:

Volgens mij is mpbb een pointer,... mpbbR een synoniem voor die pointer en mpbbS een macro die wijst naar mpbb + 256(elementen)...

Vozzie zie men eerste post, mpbb is een byte array.

[pascalbianca]

mpbb is inderdaad een Byte-Array in jou vraag.
Deze Byte-Array word dan in jou stukje verdeeld in 2 kleinere arrays namelijk.:

C Code:

#define mpbbR   (mpbb)  
#define mpbbS   (mpbb + 256)  

Die 256 houd dus in dat die mpbb in mpbbS 256 extra elementen kan bevatten buiten die wat zijn gedefineerd, dus als ik kijk naar dit stukje.:
C Code:

byte mpbb[] =  
{  
	 65,  54,  19,  98, 168,  33, 110, 187,  
	244,  22, 204,   4, 127, 100, 232,  93,  
}; 

Bevat deze Byte-Array 16 elementen, dus mpbbR  heeft dus idem 16 elementen, maar die mpbbS kan dus 16 + 256 elementen hebben oftwel 272 elementen.
Die 2 (mpbbR en mpbbS) zijn gedefinieerde variabelen die gewoon aanwijzers zijn en in die array worden gecompenseerd.

[Vozzie]

Hallo,

Ja inderdaad, had me verkeerd uitgedrukt, maar mpbbS is dus wel een pointer. (zie einde deze post)

Zoveel verschil is er wel niet tussen een pointer en array, vandaar het misverstand...

Gedeeltelijk niet akoord pascal,...

• mpbbR en mpbbS zijn GEEN variabelen, het zijn macro's(precompiler definitions)
  
  
• een char array en char pointer zijn zo goed als identiek. (de toewijzing y en z op de 2de en 3de regel hieronder geven hetzelfde resultaat, aangesproken als pointer en als array)C Code:

  char y[] = {1,2,3,4};
  char x = y[2];
  char z = *(y+2);
  

  
  
• Die mbppS wijst gewoon naar data 256 bytes verder gedefiniëerd dan mbpp. OFWEL zal je ergens in je code zien dat men aftrekt van mbppS. aka *(mbppS-250)

De vraag is dus: Wat is er gedefinieerd vlak na mpbb,...? Wijst mpbbS naar data 256 bytes verder dan mpbb?

C++ magic . In het voorbeeld hieronder wijst mpbbY naar foobar ...

C Code:

#include "stdafx.h"
#include <windows.h>

byte mpbb[] = {
	 65,  54,  19,  98, 168,  33, 110, 187,	
	244,  22, 204,   4, 127, 100, 232,  93,	
};

byte foobar[] = {
	1,2,3,4,5,6,7,8
};

#define mpbbX (mpbb)
#define mpbbY (mpbb + 16)

int _tmain(int argc, _TCHAR* argv[])
{
	
	for(int i = 0; i < 8; i++){
		// Ik spreek de array aan als een pointer
		printf("%d\n", *(mpbbY + i));
		// en niet als een array (wat hetzelfde resultaat geeft!)
		//printf("%d\n", mpbbY[i]);
	}

	getchar();
	return 0;
}

Output Code:

1
2
3
4
5
6
7
8

Er is wel verschil tussen een pointer en een array,..

C Code:

int size1 = sizeof(mpbb);
int size2 = sizeof(mpbbY);

size1 zal 16 zijn,...
size2 zal 4 zijn, omdat het een pointer is . (op 64 bit zou dit 8 zijn)

Dus mpbb is een array, mpbbS is een pointer. Wat is mpbbR dan?

Groetjes

(naar mijn gevoel opletten met optimalisatie van compiler, kan andere resultaten leveren, niet zo goede code eigenlijk, als mpbbS inderdaad gebruikt is om naar data 256 bytes verder te wijzen. Wel dit kan fout lopen indien de compiler die code anders gaat uitlijnen enzo,... een veronderstelling maar toch heb ik al zo dingen meegemaakt met uitlijning van functies...)

[pascalbianca]

Tja ik had het even op google opgezocht en hier geplaatst, dus mijn excusses als het niet geheel klopt, ga ervan uit dat het wel zou moeten kloppen wat er uitgelegt word
Daarom hou ik het liever op VB

[Vozzie]

Hallo,

C++ is een heel uitgebreide taal die toch nog heel dicht bij "native" code aanleunt.

Er is bijvoorbeeld geen grens op arrays zoals in andere talen een "out of bound". In C kan je dan wel een fout krijgen als je niet leesbaar geheugen wilt lezen,...

int * p = 0;
// zal fout geven,...
int i = *p;

Maar er is dus geen grens op een array (of pointer naar)...

C Code:

#include "stdafx.h"
#include <windows.h>

byte mpbb[] = {
	 65,  54,  19,  98, 168,  33, 110, 187,	
	244,  22, 204,   4, 127, 100, 232,  93,	
};

byte foobar[] = {
	1,2,3,4,5,6,7,8
};

int _tmain(int argc, _TCHAR* argv[])
{
	for(int i = 0; i < 24; i++){
		printf("%d, ", *(mpbb +i));
	}
	printf("\n");
	for(int i = 0; i < 24; i++){
		printf("%d, ", mpbb[i]);
	}
	getchar();
	return 0;
}

Output: Code:

65, 54, 19, 98, 168, 33, 110, 187, 244, 22, 204, 4, 127, 100, 232, 93, 1, 2, 3,
4, 5, 6, 7, 8,
65, 54, 19, 98, 168, 33, 110, 187, 244, 22, 204, 4, 127, 100, 232, 93, 1, 2, 3,
4, 5, 6, 7, 8,

* mpbbR is dus een array
* mpbbS is dus een pointer

- ik wist het ook niet zonder deze test code

C Code:

#include "stdafx.h"
#include <Windows.h>

char a [] = {1,2};

#define a1 (a)
#define a2 (a+0)

int _tmain(int argc, _TCHAR* argv[])
{

	printf("%d\n", sizeof(a));
	printf("%d\n", sizeof(a1));
	printf("%d\n", sizeof(a2));

	printf(sizeof(a1) == 2 ? "a1 is a array\n" : "a1 is a pointer\n");
	printf(sizeof(a2) == 2 ? "a2 is a array\n" : "a2 is a pointer\n");

	getchar();
	return 0;
}

Output in 32 bit mode(x86): Code:

2
2
4
a1 is a array
a2 is a pointer

Output in 64 bit mode(x64): Code:

2
2
8
a1 is a array
a2 is a pointer

Groetjes

[Vic]

Eerst en vooral dank u voor de hulp.
En 1000x sorry, dat ik dit niet bij de eerste post aanduide maar om het forum niet nutteloos te vullen heb ik slechts een beperkt aantal waarden die zich in de array mpbb bevinden weer gegeven. In feite bevinden er zich 1024 waarden in deze array.

En dus als ik het goed begrepen heb wordt er met de volgende lijn een byte pointer pbTable aangemaakt die afhankelijk van de bool fPermute ofwel naar posite 0 ofwel naar de positie 256 van de array wijst

Code:

#define mpbbR (mpbb)
#define mpbbS (mpbb + 256)

buyte * pbTable = fPermute ? mpbbR : mpbbS;

Verder zitten er nog wel wat onduidelijkheden in de C++ functie die ik oorsprongelijk gevonden heb, maar ik heb ondertussen een veel eenvoudiger C# functie  gevonden die net het zelfde doet en die ik dus wel min om meer begrijp wat er gebeurt. En dus mag deze topic gerust voor mij gesloten worden.


Mvg, Vic