Newsgroup: it.comp.lang.c++
Titolo: Funzione (o funzionale)  friend di due classi

Salve a tutti,
Ho googlato un po' in giro ma non ho trovato nulla di pertinente, se non
che, probabilmente, il problema che vado ad illustrare non è risolvibile
direttamente tramite il linguaggio quanto piuttosto tramite un qualche
pattern.
L'idea è quella di avere una funzione che manipola due oggetti di classi
distinte.
Per ragioni di performance, pensavo di far accedere la funzione agli
oggetti interni della classe, nella fattispecie dei vettori di valori,
direttamente anziché passare per le funzioni di accesso get e set.
A livello teorico ciò non è bellissimo, però la mia premura è quella di
accedere velocemente a tali valori.
Ad ogni modo, la mia idea era quella di realizzare la funzione come
friend delle due classi, tuttavia, evidentemente, ciò non è possibile in
quanto, se non sbaglio (ma potrei!) le funzioni friend vanno dichiarate
all'interno della classe stessa. Ricordo male?
Quindi vi sono solo due soluzioni:
1. Mi rassegno ed accedo ai dati tramite le funzioni di accesso get e
set, magari dichiarandole inline
2. Utilizzo un oggetto intermedio (ma non sono sicuro di guadagnare
molto in questo modo), tipo un proxy o un adaptor, devo ancora ragionarci.
Che ne pensate?
Pensandoci meglio, mi chiedevo anche se potesse, nel caso, essere utile
invece di utilizzare una funzione, utilizzare una classe funzionale,
ossia una classe che definisce il solo operatore function-call per
accedere alle classi da manipolare.
A sentore questa sarebbe LA soluzione, se non che per eseguire la
chiamata debbo instanziare un oggetto della classe... o no?
(Della serie: poche idee ma ben confuse).
Grazie in anticipo
ing. Federico Fuga

 all'interno della classe stessa. Ricordo male?
Sì, vanno dichiarate all'interno, ma possono essere definite 
all'esterno. In particolare puoi avere molte dichiarazioni e una sola 
definizione.
E.

?manu* ha scritto:

Ricordavo bene, allora.
La mia idea è quella di avere delle classi di dati e dei "funzionali"
che definiscono operazioni su tali dati.
Il concetto è quello di realizzare degli algoritmi che manipolano tali
dati. Però vorrei anche ottimizzare l'accesso, visto che molti di questi
algoritmi sono O(n^3)... Ora, non che la cosa ottimizzi un gran ché,
però sono disposto a bypassare ad esempio i check sui limiti degli array
(che ho definito nelle funzioni di accesso get e set) pur di velocizzare
l'algoritmo globale. Insomma, sto facendo la barba al pelo delle classi.
Peraltro la mia soluzione proposta li' per li' scrivendo il post
precedente non è applicabile in quanto le classi "funzionali" debbono
essere dichiarate friend nelle classi dati (sono le classi a permettere
l'accesso friend ad altre classi, non le classi che se lo imputano da sé).
Quindi mi sa che mi tocca passare tramite le funzioni di accesso.

 che definiscono operazioni su tali dati.
Non capisco. Non puoi fare così?
class B;
class A {
	...
	friend void fun(A *, B*);
};
class B {
	...
	friend void fun(A* , B*);
};
void fun(A* p, B* q) {
	// ho accesso ai membri privati di A e B
	...
}
E.

 }
ahem, si. :-) Non ci avevo in effetti pensato!
Quel che rovina i miei piani :-) è che debbo sapere in anticipo quali
funzioni possono accedere alla parte privata delle classi, rendendo
ostico l'estensibilità della libreria. Ma è ovvio che 1) chiedo troppo e
2) ciò minerebbe la protezione dei dati permessa dal linguaggio.
Pertanto, mi metto il cuore in pace e lascerò le funzioni non-friend.
Salvo che non venga in mente un qualche pattern o meccanismo per fare
altrimenti...
un HappyCactus pretenzioso

 ha scritto nel messaggio 
news:fihgjc$qha$1...@nnrp.ngi.it...

Forse potresti creare una classe C (che erediterà da entrambe le classi A e 
B)
contenente la funzione che vuoi, che potrà agire sugli elementi di A e B.