Předání dynamické velikosti paměti pro VirtualAlloc – C / C++ – Fórum – Programujte.com

Potřebuji předat funkci VirtualAlloc požadovanou velikost paměti, kterou vypočítám pomocí proměnné. Parametr je ale typu SIZE_T dwSize

Toto nefunguje,  

static const SIZE_T size_L = n1 *125;
BYTE* L_adr = static_cast<BYTE*>(VirtualAlloc(NULL, size_L, MEM_COMMIT, PAGE_READWRITE));

size_L je bez ohledu na hodnotu int n1 vždy 125.

Pokud potřebuji alkovat pamět s konkrétní hodnotou tak to funguje

static const SIZE_T giga = 1024 * 1024 * 1024;
static const SIZE_T size = 8 * giga;
BYTE* ptr = static_cast<BYTE*>(VirtualAlloc(NULL, size, MEM_COMMIT, PAGE_READWRITE));

Jak do size_L dostat vypočítanou velikost potřebné velikosit paměti ?

#1 Kevil
jakého typu je ta proměnná n1 a jak ji počítáš?

#2 Radek Chalupa
Proměnná n1 je typu int, během programu se jeji hodnota mění. Jde o počet prvků levého pomocného pole pro třídění merge sort.

#3 Kevil
uz sis vlastne odpovedel. Int je vetsinou 32b typ se znamenkem. Kdyz ho vynasobis dalsim intem (coz konstanta 125 je), tak muzes dostat jen cisla od  -2^31  az do  2^31-1.

Takze bud pretypuj int na size_t, nebo dej konstantu jako 125LL nebo  prvni prirad hodnotu do size_L a pak to na dalsim radku vynasob:  size_L *= 125;

Moznosti je strasne moc. Dulezity je, aby aspon jeden z argumentu byl 64b. Pak to nebude pretejkat na 32b

Mimochodem:

static const SIZE_T giga = 1024 * 1024 * 1024;

funguje taky jen proto, ze se to jeste vejde do int32_t bez preteceni.

#3 Kevil
to je nějaké divné, tohle normálně vypíše nějaké "náhodné" číslo které určitě není vždy 125...

int main()
{
	int n1 = GetTickCount() % 255;
	static const SIZE_T size_L = n1 * 125;
	printf("n1: %d\n", (int)n1);
	printf("size_L: %d\n", (int)size_L);
	printf("sizeof(SIZE_T): %d\n", (int)sizeof(SIZE_T));
	getchar();
}

Malý, možná nevýznamný postřeh. V kódu, který nefunguje má n1 *125, chybí mezera mezi hvězdičkou a číslem. Všude jinde tuto mezeru má. 

V nejhorším se mohu vymluvit na dodržování štábní kultury.

hu

Vyřešeno, stačilo vyhodit "static", díky radě na stackoverflow ;-)

const SIZE_T size_L = n1 *125;

Takhle to již funguje bez problémů.
 

ahoj, určitě to bude tím typováním na pravé straně, před pár dny jsem na něco podobného narazil i v Delphi, počítal jsem 64b hash z více malých čísel v 6 bitovém rozsahu (1-60), pomocí Shiftu a mizely mě ty bity v horní 1/2.

Hash UInt64 a  i int
Hash := Hash + (cislo[i] shl (i *6));   // u čísla[i] to udělalo požadovanou rotaci na úrovni 32b a to co se dostalo přes zmizlo

trvalo mi 2 dny než jsem na to přišel. Tak jsem pak upravil na 

Hash := Hash + ((UInt64)cislo[i] shl (i *6));

a nakonec jsem otočil cyklus kvůli zachování odpovídajících hodnot hash  a dokonce se to i zjednodušilo

Hash := (Hash shl 6) + cislo[i];

podobně se to chovalo, když jsem chtěl do UInt64 vynásobit 2 DWordy, tam jsem to nakonec upravil tak

UI64:=DW1;
UI64:=UI64*DW2;

a to už bylo OK.

#8 MilanL
Při práci s jednotlivými bity bych dal přednost to udělat v ASM voláním funkce z C++. Bylo by to jednodušší a s plnou kontrolou, co se děje :-).

#8 MilanL
ja bych akorat pro jistotu pridal odmaskovani vyssich bitu z toho cisla.

#9 Kevil
zbytecnost, budes akorat travit vetsinu casu na volani funkci a predavani parametru a jen kvuli par instrukcim. To si proste nech vygenerovat vystup v assembleru a zkontroluj. Ale kvuli tomu, ze neznas zakonitosti C/C++ a jake jsou implicitni datove typy, nema smysl srat do toho asm. Radeji se nauc poradne zaklady C/C++ a kdyz to bude porad pomale, tak muzes saskovat s asm.

#9 Kevil
já vím taky bych to dokázal v asm udělat, jen mám free kompilátor a ten umí jen 32b, tam jsou 2 možnosti:

1)  použít celočíselné násobení IMUL s doplňkovým registrem, jako násobič použít 1 posunutou o daný počet pozic

nebo

2) posuny, ale se 2 registry,  abych ošetřil přenos do toho vyššího řádu tzn. kopie 32b do druhého registru v jednom to odrotovat o daný počet doleva a ve druhém o 32-počet doprava 

#11 MilanL
Visual Studio 2017, které je zdarma, umí bez problémů zkompilovat externí x64 ASM funkci volanou z C++. Sám to tak používám. Jak na to je popsáno zde https://deviorel.wordpress.com/2015/01/19/compiling-64-bit-assembler-code-in-visual-studio-2014/

#12 Kevil
popravdě tohle není o možnostech, ale o fungování, nebudu přeci do 32b aplikace cpát 64b kód, kterej pak bude fungovat jen někde, jak jsem psal bylo to v Delphi a ne pro mě, ale pro známého a ten má navíc nějakou starší verzi, kde je kompiler ještě přepínanej 16/32b., 

#13 MilanL
Jasně to chápu, Samozřejmě není žádný problém to udělal ve verzi 32bitů.

#14 Kevil
jako asm pro mě není nijak velkej problém pokud budu mít instruction set, programoval jsem na střední přímo Strojovým kodem 8080 tehdejší školní počítadla IQ151

#15 MilanL
Já jsem kdysi psal v assembleru grafické rutiny pro MOS 6502, Commodore 64 ;-)

#16 Kevil
jj, to byly časy kdy se ještě programovalo, v 80-tých jsem assembleroval na EC1010, to byla sálová mašina, myslím že maďarský "klon" IBM..