Newsgroup: it.comp.lang.c
Titolo: problemi con la memset

Ciao, ho trovato il seguente codice:
   float vec[3];
  memset(&vec, 0, sizeof(float) * 3);
in mezzo a tante altre istruzioni.
Poi ho provato a contestualizzarlo nel seguente semplice programmino:
/***************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main()
{
    int i;
    float vec[3] = {1.1, 2.3, 3.3};
    for(i=0;i<3;i++) {
       printf("%f\n", vec[i]);
    }
    memset(&vec, 0, sizeof(float) * 3);
    for(i=0;i<3;i++) {
       printf("%f\n", vec[i]);
    }
    system("pause");
    return 0;
}
 /***************************************************************/
ed ho notato che anche il seguente programmino fornisce lo stesso
risultato
(ho sostituito nella memset vec in luogo di &vec, poiché vec in quanto
nome di un vettore è anche l'indirizzo della sua prima cella).
/***************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main()
{
    int i;
    float vec[3] = {1.1, 2.3, 3.3};
    for(i=0;i<3;i++) {
       printf("%f\n", vec[i]);
    }
    memset(&vec, 0, sizeof(float) * 3);
    for(i=0;i<3;i++) {
       printf("%f\n", vec[i]);
    }
    system("pause");
    return 0;
}
 /***************************************************************/
Domanda: perché utilizzare &vec anziché vec nella memset?
Seconda domanda: se nella memset pongo memset(vec, 1, sizeof(float) *
3)
in luogo di memset(vec, 0, sizeof(float) * 3) mi aspetterei che il
vettore stampato fosse tutto a 1, invece no, è ancora tutto a 0.
Perché? Se invece sostituisco memset(vec, 54, sizeof(float) * 3) in
luogo di memset(vec, 0, sizeof(float) * 3) allora il vettore stampato
è tutto a 0.00003. Perché?
Grazie a tutti

 Perché? 
Attenzione che memset considera la memoria grezza, non ha nozione del 
fatto che quella memoria rappresenta dei float. Il fatto che il float 
che rappresenta 0.0 sia rappresentato da bytes tutti 0 lo dovresti 
considerare come una (utile) coincidenza. Di certo il numero 1.0 non 
sarà rappresentato da tutti byte 1.
E.


 
perchè, per caso vec non lo è ?
-- 
La gloria è come un cerchio nell'acqua che non cessa mai d'allargarsi
finchè a furia di spandersi si sperde nel nulla.
                                             - W. Shakespeare -


memset
SYNOPSYS
void *memset(void *s, int c, size_t n);
P.S. Non è detto che chiamare una memset() per inizializzare un array
in modo da avere un certo valore per ogni cella sia più veloce (o più
chiaro per chi legge) rispetto ad un ciclo for.

fma...@gmail.com
 wrote:

chi ha detto che vuole essere più veloce ?
il topic di andrew verteva sul fatto di scrivere il puntatore a
vettore come &vec oppure come vec, il compilatore li compila 
entrambi, ma con &vec potrebbe dare un warning, è del tutto
inutile scrivere &vec quando vec è già il puntatore (quando parametro
di funzione), e poi nessun manuale indica il puntatore a vettore 
come &vec.
chi va piano va sano e lontano.
-- 
La vita è un libro del quale non ha letto che una pagina sola
chi non ha visto che il suo paese natio.
                                             - Pananti -

 perchè, per caso vec non lo è ?
Hai ragione. Diciamo che l'istruzione
	memset(&x,0,sizeof(x));
andrebbe bene per qualunque variabile x, mentre se ci togli il & va bene 
solo per i vettori.
E.


+1 per il sarcasmo. Per il resto (tanto per aggiungere informazioni
non richieste)  direi che usare &vec è, in pratica, "sbagliato". Non
solo è poco scalabile in caso si scelga di usare un array allocato
dinamicamente (float *vec; vec=malloc(3*sizeof *vec); ---> vec !=
&vec) ma io personalmente (e probabilmente non solo io), leggessi il
codice, a prima vista non mi aspetterei che &vec sia dichiarato come
un array statico.

 - Mostra testo citato -
e fino a qui sono d'accordissimo con la tua affermazione "andrebbe
bene per qualunque variabile x, mentre se ci togli il & va bene solo
per i vettori."
Invece continuo a non capire perché
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main()
{
    int i;
    float vec[3] = {1.1, 2.3, 3.3};
    memset(vec, 1, sizeof(float) * 3);
    for(i=0;i<3;i++) {
       printf("%f\n", vec[i]);
    }
    system("pause");
    return 0;
}
torni come risultato a run time
0.000000
0.000000
0.000000
Premere un tasto per continuare . . .
Anziché
1.00000
1.00000
1.00000
Boh!
Grazie per tutte le vs risposte

 un array statico.
OK, così va meglio.
scusa, non volevo fare il critico pignolo
magari dovevo aggiungere qualche faccina.
ciao
-- 
Per farsi una posizione nel mondo bisogna fare tutto il possibile
per far credere di averla già.
                                             - La Rochefoucauld -

 Grazie per tutte le vs risposte
i float sono numeri composti da 4 byte (sistema a 32 bit)
memset lavora sui byte, ne scrive uno alla volta
quindi quando scrivi con memset sui float scrivi 4 byte di valore 1
dentro ad un float.
i float internamente utilizzano alcuni bit per la mantissa, altri per
l'esponente e uno per il segno
http://it.wikipedia.org/wiki/IEEE_754
quando vai a scrivere un numero con memset chissą quali bit
vai ad influenzare, di conseguenza il float ottenuto č sbagliato.
ma lo stesso discorso č valido anche per gli interi
anche gli interi sono formati da 4 byte, con memset otterresti
00000001 00000001 00000001 00000001  - per un solo int
che chiaramente non č l'1 del memset
memset č meglio utilizzarla con stringhe o con buffer allocati,
essendo composti da byte singoli.
-- 
La legge nella sua maestosa equitą proibisce sia al ricco
sia al povero di dormire sotto i ponti, di chiedere la caritą
nelle strade e di rubare il pane.
                                             - A. France -