Newsgroup: it.comp.lang.c++
Titolo: Copiare velocemente due matrici

Salve a tutti.
Per copiare una matrice in un'altra tramite funzione membro di una classe io
sto facendo una cosa del genere:
class classe
{
float M[16];
public:
void GetFrom(const float*S)
{for (int t=0;t<16;t++) M[t]=S[t];}
};
int main(void)
{
float S[16]={...............}; //Qui metto i valori
classe miaclasse;
miaclasse.GetFrom(&S[0]);
}
Questo metodo funziona, e in piu' passo solo un puntatore, ma non mi pare un
sistema molto efficiente.
La mia idea era di copiare la zona di memoria tutta di fila.
Ho sentito parlare della funzione memcpy. Qualcuno sa in che libreria si
trova, come si usa e se è utilizzabile nel mio caso guadagnando velocita'?
Grazie in anticipo.

 trova, come si usa e se č utilizzabile nel mio caso guadagnando velocita'?
     #include <cstring>
     class classe {
         float M[16];
     public:
         void
         GetFrom(const float * S)
         {
             std::memcpy(M,S,sizeof(M));
         }
     };
Pero` non so se sia effettivamente piu` veloce di
     #include <algorithm>
     ...
     class classe {
         float M[16];
     public:
         void
         GetFrom(const float * S)
         {
             std::copy(S,S+(sizeof(M)/sizeof(M[0])),M);
         }
     };
Ho fatto delle prove da me, aumentando a dismisura le dimensioni di M, e 
fondamentalmente richiedono gli stessi tempi. (considera che da me 
sizeof(unsigned long) == sizeof(float), e che la classica ottimizzazione 
di memcpy consiste nel copiare sizeof(unsigned long) byte per ciclo).
-- 
   |   \    \  | ___|_  |_  | ianezz a casa sua... :-)
   |  _ \  | \ | _|    /   /  Visita il LinuxTrent a
  _|_/  _\_|  _|____|___|___| 
http://www.linuxtrent.it

Grazie mille.


Se stai utilizzando il gcc puoi eseguire direttamante l'assegnamento tra
matrici:
float mat1[16]  = { ... };
floaft mat2[16];
#ifdef  __GNUC__
    mat2 = mat1;
#endif
--
Ivan Molella
ICQ: 162760950

 #endif
ma cosi facendo non copieresti il puntatore alla struttura mat1 in mat2 e
basta ?
e ti renderesti mat2 fisicamente combaciante a mat1 cosi che un cambiamento
di un valore in mat1 comporta lo stesso cambiamento in mat2 ?
per copiare unarea di memoria contigua non si fa prima con memcopy tanto si
hanno gia' le dimensioni totali e l'area e' perfettamente contigua in tutte
e due le strutture ?
grazie non picchiarmi se ho detto vaccate :-p

 basta ?
No, normalmente non puoi assegnare un array ad un altro array cosi`. E` 
un'estensione al C++ del GCC (che peraltro mi sa che han tolto nel GCC 3.2).
E` piu` o meno equivalente a questa coppia di funzioni template:
     template <typename T, int size>
     void
     assign (T (&a)[size], const T(&b)[size])
     {
         std::copy(b,b+size,a);
     }
     template <typename T, int size>
     void
     assign (T (&a)[size], T(&b)[size])
     {
         std::copy(b,b+size,a);
     }
(due perche` uno puo` voler usare anche un array const come dato da 
assegnare), ma in un del tutto ipotetico overload dell'operator = (cosa 
che non si puo` fare tra tipi built-in).
Un esempio (basato su questo concetto):
----------------------------------------------------------------------
#include <iostream>
#include <algorithm>
// Copia da array const a array (ovviamente non const)
template <typename T, int size>
void
assign (T (&a)[size], const T(&b)[size])
{
     std::copy(b,b+size,a);
}
// Copia da array non-const a array (ovviamente non const)
template <typename T, int size>
void
assign (T (&a)[size], T(&b)[size])
{
     std::copy(b,b+size,a);
}
// Stampa un array non-const
template <typename T, int size>
void do_printarray(const char * prefix, const T (&a)[size])
{
     for(int i=0; i < size; i++)
     {
	std::cout <<
             prefix << "[" << i << "] == " << a[i] << std::endl;
     }
}
// Stampa un array const
template <typename T, int size>
void do_printarray(const char * prefix, T (&a)[size])
{
     for(int i=0; i < size; i++)
     {
	std::cout <<
             prefix << "[" << i << "] == " << a[i] << std::endl;
     }
}
// ...per avere il nome del parametro come const char *
#define printarray(a) do_printarray("  "#a,a);
int
main()
{
     const int array1[4] = {1,2,3,4};
     int array2[4];
     printarray(array1);
     printarray(array2);
     std::cout << "Ora copiamo..." << std::endl;
     // Copia da array1 a array2
     assign(array2,array1);
     printarray(array1);
     printarray(array2);


 #define printarray(a) do_printarray("  "#a,a);
                                               ^^^
ooops... scappato.  :-)


 ha scritto nel messaggio
news:b8r3bl$4td$1...@news.flashnet.it...
grazie di tutti i chiarimenti