[c++]Puntatore o variabile

[giuseppe500]

Ciao.
Devo assolutamente chiarirmi le idee sui puntatori e le variabili
Ho una funzone del tipo:

void CImporter::ImportVertex(CSubMeshData * subMesh)
{
	//chiamo la funzione di reset dei vertici
	m_pApi->VertexReset();
	float x,y,z;
	//finchè il reader mi restituisce true ho un vertice da importare
	//esco quando non ci sono piu' vertici
	
	for(int index = 0;m_pApi->NextVertex();index++)
	{	
		tagPositionXYZ* pos = new tagPositionXYZ();
		if(m_pApi->ImportVertex(&x,&y,&z))
		{
			pos->x = x;
			pos->y = z;
			pos->z = -y;
			
			subMesh.m_VertexBuffer.push_back(pos);			
		
		}
	}
}

questa riempie un vector di puntatori tagPositionXYZ,e quando esco dalla funzione mi conserva i dati del vector

std::vector<tagPositionXYZ> CImporter::ImportVertex(CSubMeshData  subMesh)
{
	//chiamo la funzione di reset dei vertici
	m_pApi->VertexReset();
	float x,y,z;
	//finchè il reader mi restituisce true ho un vertice da importare
	//esco quando non ci sono piu' vertici
	
	for(int index = 0;m_pApi->NextVertex();index++)
	{	
		tagPositionXYZ pos ;
		if(m_pApi->ImportVertex(&x,&y,&z))
		{
			pos.x = x;
			pos.y = z;
			pos.z = -y;
			
			subMesh.m_VertexBuffer.push_back(pos);			
		
		}
	}
	return subMesh.m_VertexBuffer;
}

questa riempie un vector di tagPositionXYZ e quando esco dalla funzione mi ritorna il vector, riempito se aggiungo la clausola return xxxx.


Al lavoro mi hanno consigliato di utilizzare dove si puo' una variabile , anche perchè non necessita di distruzione e posso sempre passarla come puntatore con &variabile.

Il problema è che se ho creato nel 2° modo un vector di variabili ed esco dalla funzione o dalla classe senza il return <vector di var> perdo i dati giusto?
quindi devo stare attento alla visibilità.
quindi quando mi consigliate di utilizzare dei puntatori e quando le variabili , in questo e in altri casi.

Grazie

[shodan]

Direi che la tua domanda denota notevoli carenze di base.
E' ovvio che se non restituisci niente, perdi i dati, ma questo succede con ogni tipo di variabile locale. Lo scegliere tra passare un puntatore o un reference è questione di ottimizzazione, non di visibilità.
se il tuo tagPositionXYZ contenesse classi o strutture di una certa complessità invece che soli tre int, sarebbe meglio passare il parametro per puntatore o (meglio) reference e questo solo per evitare il dato temporaneo allocato sullo stack (in modo trasparente) per permettere la copia dei dati uno a uno.

Contenendo solo tre int, il vector<tagPositionXYZ> può essere restituito anche per valore con penalizzazioni minime delle prestazioni (dovute più che altro a quanta roba contiene).

Se decidi di passare qualcosa per puntatore, però, devi assicurarti che sia valido.
Usando questo prototipo:

void CImporter::ImportVertex(CSubMeshData * subMesh)

e non controllando se subMesh è valido (non 0), io ti passo uno 0 e mando in crash la funzione.

void CImporter::ImportVertex(CSubMeshData& subMesh)

Invece così un reference deve essere sempre inizializzato prima di essere usato, il che aumenta la sicurezza della funzione.

[giuseppe500]

grazie...

Originariamente inviato da shodan
Se decidi di passare qualcosa per puntatore, però, devi assicurarti che sia valido.
Usando questo prototipo:

void CImporter::ImportVertex(CSubMeshData * subMesh)

e non controllando se subMesh è valido (non 0), io ti passo uno 0 e mando in crash la funzione.

void CImporter::ImportVertex(CSubMeshData& subMesh)

Invece così un reference deve essere sempre inizializzato prima di essere usato, il che aumenta la sicurezza della funzione.

scusa shodan ma non ho capito questo discorso...
il secondo esempio(refenrence) è piu' sicuro perchè è gia il compilatore che testa che il puntatore sia valido?

[shodan]

Non proprio.
Il reference è più sicuro perché il compilatore ti obbliga a inizializzarlo.
Es.

int* p = NULL;
int i = 10;
p=&i;

Uno dei tanti modi di usare un puntatore.
Col reference però non funziona. Non puoi fare:

int& p:
int i = 10;
p=i;

Perché il compilatore da errore. Sei forzato a fare:

int i = 10;
int& p=i;

Nella tua funzione (versione puntatore) nessuno vieta di fare:

obj.ImportVertex(NULL)

quindi occorre fare attenzione che il puntatore ricevuto sia valido.
Con un reference invece non si può: deve essere sempre inizializzato prima di essere usato.

CSubMeshData meshData; // Dando per scontato che il prototipo accetti un reference.
obj.ImportVertex(meshData);

Lo svantaggio del reference è che non è immediato, nel senso che se si vede un:

CSubMeshData meshData; 
obj.ImportVertex(&meshData);

si è più preparati mentalmente all'idea di puntatore, mentre col reference meno. (L'oggetto sarà passato per reference o per copia?)
E' una scelta. L'importante (tornando al topic) è che passare alla funzione un oggetto, facendo in modo che le modifiche si riflettano all'esterno, si fa quando l'oggetto ha un costo computazionale (se restituito o passato per valore) abbastanza grosso (servono test però), oppure quando la classe definisce il costruttore di copia privato (o protetto): in quel caso sei obbligato a non passarlo per valore.
Ora non so se il codice corrispondente a questa funzione (il secondo):

std::vector<tagPositionXYZ> CImporter::ImportVertex(CSubMeshData  subMesh)

sia quello effettivo. Se si, ti conviene passare solo il vector, non l'intero oggetto CsubMeshData