Realokace paměti – C / C++ – Fórum – Programujte.com

 Dobrý den, vytvořil jsem si v C funkci pro realokaci pole:

void reallocArray(char *x,unsigned int *arraySize)
{
	unsigned int oldArraySize=*arraySize;
	*arraySize+=200;

	char *newArray=(char *)malloc(((*arraySize)+1)*sizeof(char));

	for (i=0;i<=oldArraySize;++i)
	{
		newArray[i]=x[i];
	}

	int temp=*newArray;
	*x=*newArray;
	*newArray=temp;
	free(newArray);

}

Ale nějak mi s ní program nefunguje. Nevíte, kde by mohla být chyba? Díky za odpovědi

#1 kilroy
Pardon, místo int temp=*newArray; má být int temp=*x; Ale stejně mi to nefunguje...

Pro realokaci se používá funkce realloc() viz. http://www.cplusplus.com/reference/cstdlib/realloc/

V rychlosti jsem si všiml jedné chyby: Proč nově alokované pole na konci funkce uvolníš?

Jediný důvod o vlastní implementaci realloc je snaha pochopit, jak funguje.

hu

ja tam vidim chyb daleko vic....

void reallocArray(char *x,unsigned int *arraySize) // presunute "x" se nema jak dostat ven - maximalne se uvolni stare pole (ted zatim nove) a tak podobne
{
	unsigned int oldArraySize=*arraySize;
	*arraySize+=200;

	char *newArray=(char *)malloc(((*arraySize)+1)*sizeof(char)); // mame ten realloc

	for (i=0;i<=oldArraySize;++i) // mame memcpy / memmove
	{
		newArray[i]=x[i];
	}

	int temp=*newArray; // what ????? proc do tempu davas prvni byte?
	*x=*newArray;       // ano prepisu prvni pozici x prvni pozici v newArray
	*newArray=temp;     // ted to pro jistotu prepisu zase prvni pozici z newArray
	free(newArray);     // a ted to nove pole zlikviduju... 

}

#5 KIIV
jasné, už jsem to upravil..

void Realloc(char *x,unsigned int *newArraySize)
{
	*newArraySize+=200;
	char *newArray=(char *)malloc(*newArraySize+1)*ziseof(char));
	strcpy(newArray,x);
	int temp=x;
	x=newArray;
	newArray=temp;
	free(newArray);
}

Ještě mi trochu dělají problém ukazatele a zapomněl jsem, že k přepointerování nesmím dát hvězdu.. Jinak díky za odpovědi

jeste stale nedostanes ten novej pointer ven z funkce.... 

a co kdyz budes na 64b masine? int byva obvykle 32b ale pointer je 64b... ztracis najednou 32b z adresy jen tim, ze pointer narves do int

#7 KIIV
pardon, poslal jsem špatný kód.. Už si s tím hraji tak dlouho, že ani nevnímám :D  

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void Realloc(char *x,unsigned int *arraySize)
{
	*arraySize+=200;
	char *newArray=(char *)malloc((*arraySize+1)*sizeof(char));
	strcpy(newArray,x);
	char * temp=x;
	x=newArray;
	newArray=temp;
	free(newArray);
}

int main() 
{
	unsigned int arraySize=1;
	char *array=(char *)malloc(arraySize*sizeof(char));

	Realloc(array,&arraySize);
	array[10]='0';
	return 0;
}

Tohle by snad mělo být správně...

#8 kilroy
furt ti to nedostane ten pointer z Realloc ven...  pointer je taky jen hodnota... ta se pri volani zkopiruje a at uz se x zmeni jakkoliv, tak se zmenila jen ta kopie adresy uvnitr, ale ne ta venku...

Jde to 2 způsoby:
1. funkci dáš jako parametr ukazatel na ukazatel
2. funkce bude mít návratovou hodnotu ukazatel na nově alokované pole

hu

#9 KIIV

A jo, máš pravdu..

0xd21010  adresa x před zavoláním funkce..
0xd21030  adresa nového pole
0xd21030 adresa x při přeřazení
0xd21010 adresa x po skončení funkce

Takže, abych změnil adresu pole, musí funkce vracet pointer na nově vytvořené pole, že?

#10 hlucheucho
tak jsem si myslel, že už chápu docela ukazatele, ale ne :D

#11 kilroy
nemusi .. ale muze... ono totiz ta alokace muze taky selhat - to taky moc nekontrolujes

jinak bys musel bys predat ukazatel na ukazatel (char ** x)  a pak s tim tak pracovat  *x pro prepsani pointeru, **x pro ziskani prvni polozky a tak

#13 KIIV
 Super, už to nejspíš chápu a tohle je konečně funkční... :D Díky moc všem za rady

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

char* reallocArray(char *x,unsigned int *arraySize)
{
	*arraySize+=200;
	char *newArray=(char *)malloc((*arraySize+1)*sizeof(char));
	strcpy(newArray,x);
	free(x);
	return newArray;
}

int main() 
{
	unsigned int arraySize=1;
	char *array=(char *)malloc((arraySize+1)*sizeof(char));

	array=reallocArray(array,&arraySize);
	array[10]='0';
	return 0;
}

Asi spoléháš na to, že pole char obsahuje vždy řetězec. memcpy by bylo univerzální

hu

#15 hlucheucho
ještě, jestli můžu otravovat, tak verze s parametrem bude vypadat takhle, že? 

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void reallocArray( char **pointer,unsigned int *arraySize)
{
	*arraySize+=200;
	char *newArray=(char *)malloc((*arraySize+1)*sizeof(char));
	strcpy(newArray,*pointer);
	*pointer=newArray;
}

int main() 
{
	unsigned int arraySize=10;
	char *array=(char *)malloc((arraySize+1)*sizeof(char));


	char **pointer;
	*pointer=array;
	reallocArray(pointer,&arraySize);
	array=*pointer;


	array[10]='0';
	return 0;
}

#16 kilroy
ted zase neuvolnujes pamet po tom puvodnim

#17 KIIV
Jasné, vlastně ani v té verzi, která vrací hodnotu není v mainu uvolnění... To ale teďka neřeším, jde mi pouze o to, jestli jsem konečně ty zatracené ukazatele pochopil :)

#18 kilroy
ne jen v mainu ale i v reallocArray neuvolnujes

A je tohle správně:  

char **pointer;
	*pointer=array;
	reallocArray(pointer,&arraySize);
	array=*pointer;

nebo to má vypadat takhle:  

	char **pointer;
	char *pointer2;
	*pointer=pointer2;
	reallocArray(pointer,&arraySize);
	array=*pointer;

byt tebou tak pouziju:   reallocArray(&array, &arraySize);  bez tech saskaren okolo