[C] Puntatore oppure no?

[/dev/null]

Ho da tre giorni un problema stranissimo che non riesco a risolvere

Secondo voi al codice all'interno di funzione() cambia qualcosa tra i due pezzetti di codice seguenti? :

type VAR;
funzione ( & VAR );

type * VAR = malloc ( sizeof(type);
funzione ( VAR );

Certo che no!
Ma invece con un mio programmino sembra proprio di si'






Ecco il codice:

#include <stdio.h>
#include <SDL/SDL.h>
#include <SDL/SDL_image.h>
#include <SDL/SDL_rotozoom.h>
#include <stdlib.h>
#include <malloc.h>

#define IMGS_NUM	( 10 )

typedef struct _SZ_
{
	SDL_Surface * screen, * imgs [ IMGS_NUM ];
} SZ;


SZ * initgame ( SZ * sz );


int main ( )
{
	SZ * sz = malloc ( sizeof(SZ) );
	//SZ sz;
	
	initgame ( sz );
	//initgame ( & sz );
	
	return 0;
}

SZ * initgame ( SZ * sz )
{
	int i;
	char * imgpath;
	SDL_Rect src, dest;
	
	// Prova ad abilitare le SDL
	if ( SDL_Init ( SDL_INIT_VIDEO ) < 0 ) {
		fprintf ( stderr, "Impossibile abilitare le SDL: %s\n", SDL_GetError() );
		return NULL;
	}
	
	// Prima di uscire le SDL vengono disabilitate
	atexit ( SDL_Quit );
	
	// Setto la modalita' video richiesta e controllo se e' stata abilitata
	if ( ( sz->screen = SDL_SetVideoMode ( 800, 600, 0, SDL_HWSURFACE | SDL_DOUBLEBUF ) ) == NULL ) {
		fprintf ( stderr, "Imposibile settare la modalita' video: %s\n", SDL_GetError() );
		return NULL;
	}
	
	imgpath = (char *) malloc ( 10240 );
	
	// carico tutte le immagini
	for ( i = 0; i < IMGS_NUM; i ++ ) {
		sprintf ( imgpath, "imgs/%d.jpg", i+1 );
		sz->imgs[i] = IMG_Load ( imgpath );
		if ( sz->imgs[i] == NULL ) {
			printf ( "Non sono riuscito a caricare l'immagine %s.\n", imgpath );
			return NULL;
		}
		
		src.w = sz->imgs[i]->w;
		src.h = sz->imgs[i]->h;
		dest.x = 0;
		dest.y = 0;
		printf ( "Print @ %d, %d: %d, %d\n", dest.x, dest.y, src.w, src.h );
		SDL_BlitSurface ( sz->imgs[i],  & src, sz->screen, & dest);
		SDL_UpdateRect ( sz->screen, 0, 0, 0, 0 );
	}
	
	free ( imgpath );
	
	return sz;
}

*Il programma si compila con `gcc -lSDL -lSDL_image -lSDL_gfx -o prova prova.c` ed e' necessario avere installate le SDL, le SDLimage e le SDLgfx.
* E necessario inoltre che nella dir dove si trova l'eseguibile ci sia una sottodir chiamata "imgs" che contenga 10 immagine chiamate "1.jpg", "2.jpg", "3.jpg" ... "10.jpg"



Vedete le quattro linee in grassetto?
Se le invertite (scommentate le due che attualmente sono commmentate e fate l'opposto con le altre due) il programma si comporta in maniera completamente diversa...
Succede che in un caso le immagini vengono stampate nella finestra, mentre nell'altro caso non viene stampato nulla

Perche'???






EDIT: Ho studiato il comportamento del programma con il debugger GDB, e mi sono accorto che e' la SDL_BlitSurface che non fa cio' che dovrebbe...
Pero' il valore che restituisce e' quello che restituisce in caso di successo, ed inoltre a lei cosa cambia di com'e' stato definito sz???

[Ed_Bunker]

Penso che con la malloc tu non abbia problemi. Se e' cosi, prova (Nell'altro caso) a inizializzare VAR con un valore "null" prima di chiamare la funzione a cui passi il puntatore.

[/dev/null]

Originariamente inviato da Ed_Bunker
Penso che con la malloc tu non abbia problemi.

Invece ne ho
Lo so, va contro ogni legge fisica del C, ma e' cosi'

Se e' cosi, prova (Nell'altro caso) a inizializzare VAR con un valore "null" prima di chiamare la funzione a cui passi il puntatore.

Ho gia' provato...
Dopo la malloc c'ho messo un memset che setta tutto completamente a zero in quella variabile (lo stesso memset viene eseguito in entrambi i casi), ma non cambia niente.




Ah, mi sono scordato di dire una cosa...
La variabile che passo alla funzione va bene in entrambi i casi... Ha sempre gli stessi valori e non da problemi...
I problemi li da la funzione SDL_BlitSurface, anche se i valori che gli vengono passati sono del tutto e per tutto identici...




Non riesco a darmi una spiegazione razionale, se non un possibile bug del GCC VVoVe:
Ho il GCC 3.3.4: gcc (GCC) 3.3.4 20040623 (Gentoo Linux 3.3.4-r1, ssp-3.3.2-2, pie-8.7.6)
E le SDL 1.2.7-rc2

[gandalf45]

Non riesco a darmi una spiegazione razionale, se non un possibile bug del GCC
Ho il GCC 3.3.4: gcc (GCC) 3.3.4 20040623 (Gentoo Linux 3.3.4-r1, ssp-3.3.2-2, pie-8.7.6)
E le SDL 1.2.7-rc2

E' semplice invece: le SDL sono malvagie

Passando a cose serie mi è venuta un'idea... prova a rendere *sz globale e cambiagli nome(potrebbe esistere già una variabile con questo nome).

...
SZ *test;
...
int main(){
test = malloc(sizeof(SZ));
initgame ( test );
...

Probabilmente non cambierà niente ma fa lo stesso una prova

[/dev/null]

Originariamente inviato da gandalf45
E' semplice invece: le SDL sono malvagie

Bhe', di questo non ne ho alcun dubbio
Pero' sono facili... E quando voglio fare qualcosa in fretta uso quello...

Comunque questo errore NON PUO' essere delle sdl (almeno secondo mie conoscenze del C ) perche' loro non hanno modo di sapere come e' stata dichiarata quella variabile.

Passando a cose serie mi è venuta un'idea... prova a rendere *sz globale e cambiagli nome(potrebbe esistere già una variabile con questo nome).

...
SZ *test;
...
int main(){
test = malloc(sizeof(SZ));
initgame ( test );
...

Probabilmente non cambierà niente ma fa lo stesso una prova

Ho appena provato per sicurezza, ma non e' cambiato nulla...
Prima non ho provato perche' non ha molto senso: se c'e' qualcosa chiamato SZ (come la struttura) la compilazione fallirebbe...
Se c'e' qualcosa chiamato sz (come la variabile) non cambierebbe nulla, dato che le varie funzioni che chiamo vedono quella variabile con il nome che scelgono loro, e non con il nome che gli ho dato io.

[gandalf45]

e hai provato a dichiarare il puntatore fuori da int main() (globale) ?

[/dev/null]

Originariamente inviato da gandalf45
e hai provato a dichiarare il puntatore fuori da int main() (globale) ?

Certo!
L'ho fatto quando hai postato il vecchio messaggio... Prima l'ho reso soltanto globale e poi gli ho cambiato nome...
Ma nulla

[gandalf45]

ultimo tentativo... apparentemente senza senso... prova a fare il malloc dentro la funzione init...

sembrerebbe che syzeof non capisca bene la grandezza di SZ...

[/dev/null]

Originariamente inviato da gandalf45
ultimo tentativo... apparentemente senza senso... prova a fare il malloc dentro la funzione init...

Cosi' funziona come nel caso che sz sia una variabile normale...
Cio' rende il caso ancora piu' strano e secondo me non fa che confermare la mia idea che sia colpa del compilatore

sembrerebbe che syzeof non capisca bene la grandezza di SZ...

Cosa ti fa pensare che il problema sia questo? :master:
Comunque il problema non e' questo: l'ho verificato mettendo una `printf ( "SZ e' grosso %d.\n", sizeof(SZ) );` sia dentro la init sia dentro la main...
Inoltre e' abbastanza ovvio che il problmea non e' questo: altrimenti il programma crasherebbe e poi e' impossibile che un compilatore non riesca ad usare la sizeof



Grazie ancora per i tuoi interventi...
Se hai altre idee rifatti avanti

[/dev/null]

Ho scaricato un altro compilatore al posto del GCC...
Ho preso quello dell'Intel: http://www.intel.com/software/produc...lin/noncom.htm


Il programmino che ho postato prima dovrebbe caricare delle immagini e man mano che le carica dovrebbe mostrarle nella finestra...

Usando il GCC, nel caso che io dichiaro sz come variabile mi stampa tutte le immagini correttamente... Se invece dichiaro sz come un puntatore e lo alloco nella main non mi mostra nulla... Se lo dichiaro come puntatore, ma lo alloco nell'altra funzione mi stampa di nuovo tutto correttamente...
Che senso puo' avere questa cosa?
Cosa potrebbe spiegare questo comportamento?

Usando l'ICC (il compilatore dell'Intel) invece le immagini non vengono mostrate in nessun caso... Lasciando perdere il fatto che il risultato non e' quello desiderato (magari non ho richiamato le funzioni delle SDL nel modo giusto...), avviene almeno che questo compilatore non ha lo stesso problema del GCC...

Questa cosa mi fa pensare ancora di piu' ad un problema (un bug) del GCC...
...Che ne pensate?