Stampare l'indirizzo dei 4 byte allocati per un intero in C senza cast @ (char*)

[swarzy85]

Ciao
come da titolo, mi interessa sapere come fare per riuscire a stampare gli indirizzi dei 4 byte consecutivi allocati per un intero, senza utilizzare il cast @ (char*).

Esempio con cast (solo estratto di un programma...giusto per dare un'idea):

int i, v[5];

for (i=0; i<5; i++)
{
    v[i]=i;
    printf ("%d %d %d %d", (char*)&v[i]+3, (char*)&v[i]+2, (char*)&v[i]+1, (char*)&v[i]);
}

Senza cast non riesco a farlo...
Scrivendo soltanto v, si ottiene un puntatore costante al primo byte del vettore v.

Ovviamente, se scrivo v+1, verrà esseguita una conversione di tipo e, se sto cercando di stampare il secondo byte dell'intero salvato in v[0], avrò stampato in realtà l'indirizzo di v[1] dato che salterà di 4 byte in 4 byte.

Devo riuscire a stampare i 4 byte corretti per ogni intero, senza usare il cast.

Help

[fek]

  int address = &v[i];   // cast implicito
  printf("%d %d %d %d", address + 3, address + 2, address + 1, address);

[swarzy85]

Ciao Francesco

ho provato a riscrivere velocemente il programma (era il primo esonero di fondamenti 2 da correggere....in pratica mancavano diversi puntatori e ce n'erano altri messi a caso)

#include <stdio.h>
#include <malloc.h>

void alloc (int **, int);
void setta (int *, int);
void stampa_su_file (int*, int);


void main ()
{
	int n;
	int *v=NULL;
	
	printf ("Inserire il numero di elementi: ");
	scanf ("%d", &n);
	alloc (&v, n);
	setta (v, n);
	stampa_su_file (v, n);
	free (v);
}

void alloc (int **v, int n)
{
	*v = (int*) malloc (n * sizeof (int));
}
	
void setta (int *v, int n)
{
	int i;
	for (i=0; i<n; i++)
	v[i] = i;
}

void stampa_su_file (int *v, int n)
{
	FILE *fp;
	int i, address;
	
	fp = fopen ("uscita.txt", "w");

	for (i=0; i<n; i++)
	{
		address = &v[i];
		fprintf (fp, "v[%d] che si trova ai byte numero %d %d %d %d vale = %d\n", i, address+3, address+2, address+1, address, i);
	}
	fclose (fp);
}

Ho fatto come mi hai consigliato e funziona perfettamente
Ieri avevo provato a fare la stessa cosa ma mi dava un errore in compilazione...
appena ho provato a fare ciò che mi hai indicato, mi ha dato il medesimo errore...
in pratica lo compilavo in C++

Grazie ancora

[fek]

Originariamente inviato da swarzy85

Ciao Francesco

Ciao

appena ho provato a fare ciò che mi hai indicato, mi ha dato il medesimo errore...
in pratica lo compilavo in C++

Grazie ancora

Era un errore oppure un warning? Perche' trattare un puntatore come un intero in C++ e' una cosa che non andrebbe mai fatta e molti compilatori lo segnalano con un warning.

Ma perche' vi insegnano cose come queste all'Universita'? Fa il paio con i lucidi che usano i float come parametri per un template.

[Fenomeno85]

Originariamente inviato da fek

Ciao



Era un errore oppure un warning? Perche' trattare un puntatore come un intero in C++ e' una cosa che non andrebbe mai fatta e molti compilatori lo segnalano con un warning.

Ma perche' vi insegnano cose come queste all'Universita'? Fa il paio con i lucidi che usano i float come parametri per un template.

guarda che i puntatori si possono tranquillamente usare come "interi" cioè sommando ... è l'algebra dei puntatori ed è impossibile che dia warning


~§~ Sempre E Solo Lei ~§~

[cionci]

Originariamente inviato da Fenomeno85

guarda che i puntatori si possono tranquillamente usare come "interi" cioè sommando ... è l'algebra dei puntatori ed è impossibile che dia warning

Il problema non era l'utilizzo come interi, ma il casting implicito che in C++ va esplicitato...mentre in C funziona senza problemi...

[repne scasb]

A meno di errori grossolani:

    int i, v[5];

    for (i=0; i<5; i++)
        printf ("%d %d %d %d\n",++v[i]+(v[i]=i)-i,++v[i],++v[i],v[i]=&v[i]);

NOTE: a) L'esecuzione del codice nella printf si legge da destra verso sinistra.
b) v[i]=i, e' implicitamente assegnato al termine dei "push" sulla printf.

[fek]

Originariamente inviato da repne scasb

A meno di errori grossolani:

    int i, v[5];

    for (i=0; i<5; i++)
        printf ("%d %d %d %d\n",++v[i]+(v[i]=i)-i,++v[i],++v[i],v[i]=&v[i]);

NOTE: a) L'esecuzione del codice nella printf si legge da destra verso sinistra.
b) v[i]=i, e' implicitamente assegnato al termine dei "push" sulla printf.

Lo Standard C++ non da' garanzie sull'ordine di valutazione degli argomenti di una chiamata a funzione. Questo codice e' "Undefined" in C++.

Non ricordo a memoria se lo Standard del C da' garanzia sull'ordine di valutazione (mi sembrerebbe molto strano se lo facesse).

[repne scasb]

Originariamente inviato da fek

Lo Standard C++ non da' garanzie sull'ordine di valutazione degli argomenti di una chiamata a funzione. Questo codice e' "Undefined" in C++.

Non ricordo a memoria se lo Standard del C da' garanzia sull'ordine di valutazione (mi sembrerebbe molto strano se lo facesse).

Il passaggio dei parametri puo' avvenire da destra verso sinistra da sinistra verso destra, con allineamento dello stack a carico del chiamante o del chiamato, per registro, o in altri modi piu' o meno esotici.

I due metodi piu' utilizzati sono da destra a sinistra con stack a carico del chiamante, e da sinistra a destra con stack a carico del chiamato. Il secondo metodo si chiama "passaggio di paramentri con convenzione pascal", il primo "standard C". Ci sarebbe da verificare se il primo metodo chiamato "standard C" e' in effetti uno standard del C.

Nonostante cio', esiste comunque la possibilita' di verificare all'interno del codice stesso la modalita' di passaggio dei paramentri sullo stack:

{
    a=0;
    a=func(a--,a++)
    if(a>0)
	printf("Da destra a sinistra\n");
    else
	printf("Da sinistra a destra\n");
}

func(int a,int b)

{
	return(a+b);
}

Quindi nel nostro caso (sempre a meno di errori grossolani):

{
    int i, v[5];
    a=0;

    a=func(a--,a++)
    if(a>0)
        printf ("%d %d %d %d\n",++v[i]+(v[i]=i)-i,++v[i],++v[i],v[i]=&v[i]);
    else
        printf ("%d %d %d %d\n",v[i]=&v[i],++v[i],++v[i],++v[i]+(v[i]=i)-i);
}

func(int a,int b)

{
	return(a+b);
}

[swarzy85]

Originariamente inviato da fek

Ciao

Era un errore oppure un warning? Perche' trattare un puntatore come un intero in C++ e' una cosa che non andrebbe mai fatta e molti compilatori lo segnalano con un warning.

Ma perche' vi insegnano cose come queste all'Universita'? Fa il paio con i lucidi che usano i float come parametri per un template.

Era proprio un errore Francesco (il succo era che non poteva convertire un int* in int)
Uso Visual Studio 6.0 come compilatore.

Perchè ci insegnano queste cose? Veramente non ce le hanno insegnate
Per la fine del corso bisognava portare un programma intero in C++ su un argomento a scelta (tra 6 proposti).
Io ho portato un software di gestione aziendale...erano circa 2000 righe di codice; diciamo che ho imparato un sacco di cose (soprattutto l'utilità delle STL in certe occasioni).

Poi, però, all'orale venivano fatte altre domande...domande tipo quella che ho posto io qui.
A me è stato chiesto di stampare gli indirizzi di un intero e l'ho fatto con il cast @ char*.
Poi mi è stato chiesto di farlo senza cast e all'inizio ho detto una cavolata immane. Allora, mentre veniva interrogato un altro ragazzo, dovevo provare a trovare una soluzione. Ho commesso l'errore grossolano di creare un .cpp e quindi mi restituiva errore; di conseguenza, quando il professore mi ha chiesto a che punto fossi, ho risposto che non ero riuscito a combinare nulla.

[swarzy85]

Originariamente inviato da cionci

Il problema non era l'utilizzo come interi, ma il casting implicito che in C++ va esplicitato...mentre in C funziona senza problemi...

esatto, dovrebbe essere una situazione analoga a quella che si presenta quando si usa la malloc in C e in C++ (nel primo caso non serve il cast, nel secondo è necessaria....infatti io avevo scritto un .cpp):

*v = (int*) malloc (n * sizeof (int));

[fek]

Originariamente inviato da repne scasb

Il passaggio dei parametri puo' avvenire da destra verso sinistra da sinistra verso destra, con allineamento dello stack a carico del chiamante o del chiamato, per registro, o in altri modi piu' o meno esotici.

No. Standard C++ alla mano, anche questo codice e' illegale, perche' la valutazione dei parametri e il loro passaggio dei possono essere in qualunque ordine, anche del tutto casuale, per lasciare al compilatore il totale controllo sull'ottimizzazione. Il compilatore e' libero di valutare i parametri per la stessa chiamata da sinistra verso destgra una volta, da destra verso sinistra la seconda volta, o in qualunque ordine gli aggrada anche all'interno dello stesso programma.

Qualunque codice il cui corretto funzionamento dipende da una particolare assunzione sull'ordine di valutazione e' "Undefined" e non e' C++.

http://www.gotw.ca/gotw/012.htm

    int f( int& x, int y = x ) { return x += y; }
    int g( int& x )             { return x /= 2; }

    int main( int, char*[] ) {
        int i = 42;
        cout << "f(" << i << ") = " << f(i) << ", "
             << "g(" << i << ") = " << g(i) << endl;

Here we run into parameter evaluation ordering again. Since there's no telling the order in which f(i) or g(i) will be executed (or, for that matter, the ordering of the two bald evaluations of 'i' itself), the printed results can be quite incorrect. One example result is MSVC's "f(22) = 22, g(21) = 21", which means the compiler is likely evaluating all function arguments in order from right to left.

But isn't the result wrong? No, the compiler is right... and another compiler could print out something else and still be right, too, because the programmer is relying on something that is undefined in C++.

[swarzy85]

Originariamente inviato da repne scasb

A meno di errori grossolani:

    int i, v[5];

    for (i=0; i<5; i++)
        printf ("%d %d %d %d\n",++v[i]+(v[i]=i)-i,++v[i],++v[i],v[i]=&v[i]);

NOTE: a) L'esecuzione del codice nella printf si legge da destra verso sinistra.
b) v[i]=i, e' implicitamente assegnato al termine dei "push" sulla printf.

Ciao
grazie per l'informazione, non conoscevo l'ordine di lettura della printf

Riguardo la tua soluzione:
secondo il tuo ragionamento, visto che la lettura avviene da destra verso sinistra assegni a v[i] il suo indirizzo. In tal modo ti basta incrementare di 1 l'indirizzo con la notazione prefissa del "++".
Quando viene stampato l'ultimo byte (...il primo nella printf), però, perchè incrementi il valore dell'inidirzzo di 1 e aggiungi e sottrai i?

P.S. adesso lo provo

[fek]

Originariamente inviato da swarzy85

Ciao
grazie per l'informazione, non conoscevo l'ordine di lettura della printf

E continui a non conoscerlo perche' l'ordine e' indefinito e dipende da compilatore a compilatore

[swarzy85]

Originariamente inviato da fek

E continui a non conoscerlo perche' l'ordine e' indefinito e dipende da compilatore a compilatore

Mhmhm capito
ora provo a vedere cosa succede con il Visual Studio.
Comunque volevo chiederti un'altra cosa: non è possibile trovare una soluzione senza appoggiarsi ad un intero (per fargli salvare l'indirizzo)? In pratica, mi chiedo se si potrebbe ottenere un risultato analogo usando nella fprintf solo l'operatore + per fargli eseguire un cast implicito?

Te lo domando perchè il professore ha provato a darmi un imput dicendomi che in C viene eseguita una conversione di tipo automatica quando si usa l'operatore + in un certo modo.
Sinceramente non riesco a trovare altre soluzioni a parte quella che mi hai indicato tu

[swarzy85]

In questo modo funziona:

fprintf (fp, "v[%d] che si trova ai byte numero %d %d %d %d vale = %d\n", i, ++v[i], ++v[i], ++v[i], v[i]=&v[i], i);

[fek]

Originariamente inviato da swarzy85

Te lo domando perchè il professore ha provato a darmi un imput dicendomi che in C viene eseguita una conversione di tipo automatica quando si usa l'operatore + in un certo modo.
Sinceramente non riesco a trovare altre soluzioni a parte quella che mi hai indicato tu

Hmmm... Francamente non riesco ad immaginare in quale modo potrebbe essere usato l'operatore + per causare un cast implicito a int di un puntatore

[fek]

Originariamente inviato da swarzy85

In questo modo funziona:

fprintf (fp, "v[%d] che si trova ai byte numero %d %d %d %d vale = %d\n", i, ++v[i], ++v[i], ++v[i], v[i]=&v[i], i);

Non e' C/C++ per il motivo di prima. Il risultato e' "Undefined" e dipende dal compilatore/giorno della settimana/tempo atmosferico.

[swarzy85]

Originariamente inviato da fek

Non e' C/C++ per il motivo di prima. Il risultato e' "Undefined" e dipende dal compilatore/giorno della settimana/tempo atmosferico.

Si si, ho capito, tranquillo

Si vede che sbatterò la testa contro il muro finchè non troverò un'altra soluzione (o finchè il muro non sarà diventato tutto rosso)

P.S. stamattina non avevo niente da fare e ho scaricato alcuni file .cpp. Ho visto delle librerie tipo dos.h, windows.h e winsock.h che mi ispirano parecchio
Partendo dal presupposto che la programmazione non mi piace nemmeno un pò...sta diventando una sfida personale

[repne scasb]

Originariamente inviato da fek

No. Standard C++ alla mano............

Non sto parlando di C++ in quanto il messaggio d'aiuto originario chiede: "Stampare l'indirizzo dei 4 byte allocati per un intero in C senza cast @" e non si fa alcun cenno di C++. La mia risposta e' quindi strettamente attinente a quanto chiesto. Se ne deduce che il codice piu' sopra inviato non e' C++ ma C (per la precisione e' C--).