[C] confronto tra puntatori & ISO

[Oceans11]

Per esercizio, sto tentando di implementare le varie funzioni di string.h.
Ho dei problemi con memmove.
Partiamo da memcpy, caso particolare di memmove in cui i puntatori passati come parametro non puntano ad oggetti in memoria che si sovrappongono:

void *memcpy(void *dest, const void *src, size_t n) {
    unsigned char *d = dest;
    const unsigned char *s = src;
    while (n--) {
        *d++ = *s++;
    }
    return dest;
}

codice non testato, anche se sembra abbastanza semplice. Qui l'unico dubbio è nell'uso di "unsigned": io l'ho usato, ma non saprei dire se va bene, se ci vuole "signed" e quali sono (se ci sono) differenze.

Memmove, invece, dovrebbe coprire anche il caso in cui gli oggetti sorgente e destinazione overlappano.
Dalla pagina di manuale:

The memmove() function copies n bytes from memory area src to memory
area dest. The memory areas may overlap: copying takes place as
though the bytes in src are first copied into a temporary array that
does not overlap src or dest, and the bytes are then copied from the
temporary array to dest.

void *memmove(void *dest, const void *src, size_t n) {
	// dest < src, then copy from the beginning
		return memcpy(dest, src, n);
	}
	// otherwise copy from the end
	unsigned char *d = dest;
	const unsigned char *s = src;
	s += n;
	d += n;
	while (n--) {
		*--d = *--s;
	}
	return dest;
}

Leggendo in rete, trovo un riferimento ad un paragrafo dello standard (in realtà è un documento che si avvicina allo standard ISO/IEC 9899:TC2 WG14/N1124) che riporto per intero:

6.5.8.5 When two pointers are compared, the result depends on the relative locations in the address space of the objects pointed to. If two pointers to object or incomplete types both point to the same object, or both point one past the last element of the same array object, they compare equal. If the objects pointed to are members of the same aggregate object, pointers to structure members declared later compare greater than pointers to members declared earlier in the structure, and pointers to array elements with larger subscript values compare greater than pointers to elements of the same array with lower subscript values. All pointers to members of the same union object compare equal. If the expression P points to an element of an array object and the expression Q points to the last element of the same array object, the pointer expression Q+1 compares greater than P. In all other cases, the behavior is undefined.

e qui nascono i problemi, per tutti i casi non citati (ossia oltre a puntatori allo stesso array, struct o union)
1) cosa si intende per "object"?
2) cosa significa "relative locations in the address space"
3) perchè non posso confrontare i 2 puntatori come 2 interi per verificare se le regioni si sovrappongono?

[sottovento]

Originariamente inviato da Oceans11

void *memcpy(void *dest, const void *src, size_t n) {
    unsigned char *d = dest;
    const unsigned char *s = src;
    while (n--) {
        *d++ = *s++;
    }
    return dest;
}

E' corretta, ma si potrebbe ottimizzare. Ricordo che il problema era stato affrontato anni fa in questo forum. Ma immagino che il tuo problema non fosse quello di ottimizzare questo codice, giusto?

Originariamente inviato da Oceans11

codice non testato, anche se sembra abbastanza semplice. Qui l'unico dubbio è nell'uso di "unsigned": io l'ho usato, ma non saprei dire se va bene, se ci vuole "signed" e quali sono (se ci sono) differenze.

Va benissimo, non preoccuparti. Devi preoccuparti dell'uso di "signed/unsigned" quando inavvertitamente potresti fare delle estensioni del segno e cambiare il risultato atteso.
per esempio: se leggi dalla memoria un byte alla volta e poi vuoi processare questo byte come un intero, allora potresti avere risultati ben diversi a seconda dell'uso di signed/unsigned, poiche' se il byte letto da memoria e', poniamo
byteVal=F8,
allora se fai

int iVal = (int)byteVal;
unsigned int uVal = (unsignedbyteVal;

otterrai
iVal=-8
uVal=4294967288

Originariamente inviato da Oceans11

e qui nascono i problemi, per tutti i casi non citati (ossia oltre a puntatori allo stesso array, struct o union)
1) cosa si intende per "object"?
2) cosa significa "relative locations in the address space"
3) perchè non posso confrontare i 2 puntatori come 2 interi per verificare se le regioni si sovrappongono?

Da quanto ho capito io, e' corretto ed il tuo codice lo e' altrettanto.
1) Oggetto sembra indicare, in questo contesto, qualsiasi tipo di dato strutturato;
2) significa che sei giovane . Con l'avvento delle MMU (una delle tante sigle, usata soprattutto per i processori Motorola, per indicare il "Memory Management Unit", vale a dire l'unita' di memoria virtuale) ogni processo ha a disposizione uno "spazio di indirizzamento virtuale" o piu' semplicemente "address space".
Address space e' piu' generico poiche' fa rientrare anche il caso dei processori che la MMU non ce l'hanno.
Detto semplicemente: quando assegni un valore ad un puntatore, esso e' valido nel tuo spazio di indirizzamento. In una specifica pero' devono parlare in maniera generica e formale.
3) Non preoccuparti, puoi confrontari. La specifica che hai riportato non dice che non puoi confrontarli, ma specifica dei casi in cui il confronto deve avere senso, lasciando indeterminati tutti gli altri casi.
Da quanto scritto nella specifica sappiamo che le strutture dovranno essere allocate in memoria in modo tale che gli elementi dichiarati prima abbiano indirizzo minore di quelli dichiarati dopo, che i vettori seguono piu' o meno lo stesso criterio, ...

A rigor di logica si potrebbe pensare ad un sistema in cui questo non e' valido, ma sarebbe un processore progettato apposta per far fallire il tuo codice. Per quanto riguarda la mia umile esperienza, non ho mai visto nulla del genere ma magari il contributo di qualcuno puo' portare un esempio reale.

[Daniels118]

L'unica cosa che ci si avvicina è la gestione dello stack sui processori x86: le istruzioni di push non incrementano lo stack pointer ma lo decrementano, per cui gli elementi inseriti dopo hanno un indirizzo minore di quelli inseriti prima, ma parliamo di elementi appartenenti a strutture diverse, quindi siamo ancora conformi alla specifica.
Forse i processori giapponesi funzionano al contrario... scherzo!

[Oceans11]

Originariamente inviato da sottovento

E' corretta, ma si potrebbe ottimizzare. Ricordo che il problema era stato affrontato anni fa in questo forum. Ma immagino che il tuo problema non fosse quello di ottimizzare questo codice, giusto?

Giustissimo, ho molte lacune da colmare prima di poter pensare all'ottimizzazione. Ad ogni modo farò una ricerca più approfondita qui sul forum

Originariamente inviato da sottovento

Va benissimo, non preoccuparti. Devi preoccuparti dell'uso di "signed/unsigned" quando inavvertitamente potresti fare delle estensioni del segno e cambiare il risultato atteso.
per esempio: se leggi dalla memoria un byte alla volta e poi vuoi processare questo byte come un intero, allora potresti avere risultati ben diversi a seconda dell'uso di signed/unsigned, poiche' se il byte letto da memoria e', poniamo
byteVal=F8,
allora se fai

int iVal = (int)byteVal;
unsigned int uVal = (unsignedbyteVal;

otterrai
iVal=-8
uVal=4294967288

Ok. Mi era venuto il dubbio perchè in alcune pagine di manuale c'è scritto esplicitamente come deve essere trattato il dato (e.g. memchr)

Originariamente inviato da sottovento

Da quanto ho capito io, e' corretto ed il tuo codice lo e' altrettanto.
1) Oggetto sembra indicare, in questo contesto, qualsiasi tipo di dato strutturato;
2) significa che sei giovane . Con l'avvento delle MMU (una delle tante sigle, usata soprattutto per i processori Motorola, per indicare il "Memory Management Unit", vale a dire l'unita' di memoria virtuale) ogni processo ha a disposizione uno "spazio di indirizzamento virtuale" o piu' semplicemente "address space".
Address space e' piu' generico poiche' fa rientrare anche il caso dei processori che la MMU non ce l'hanno.
Detto semplicemente: quando assegni un valore ad un puntatore, esso e' valido nel tuo spazio di indirizzamento. In una specifica pero' devono parlare in maniera generica e formale.
3) Non preoccuparti, puoi confrontari. La specifica che hai riportato non dice che non puoi confrontarli, ma specifica dei casi in cui il confronto deve avere senso, lasciando indeterminati tutti gli altri casi.
Da quanto scritto nella specifica sappiamo che le strutture dovranno essere allocate in memoria in modo tale che gli elementi dichiarati prima abbiano indirizzo minore di quelli dichiarati dopo, che i vettori seguono piu' o meno lo stesso criterio, ...

A rigor di logica si potrebbe pensare ad un sistema in cui questo non e' valido, ma sarebbe un processore progettato apposta per far fallire il tuo codice. Per quanto riguarda la mia umile esperienza, non ho mai visto nulla del genere ma magari il contributo di qualcuno puo' portare un esempio reale.

Mi aiuti a chiarire il 3) punto? Ci sono sui casi in cui i puntatori appartengono allo stesso array/struct/union, tutto ha perfettamente senso.
Ma che succede nel caso confronto 2 puntatori a 2 oggetti diversi?
Behavior undefined sta per machine e compiler dependent?
Se in questo caso non sono interessato all'aritmetica dei puntatori, proprio in virtù dello spazio virtuale di indirizzamento (che dovrebbe darmi un livello maggiore di astrazione, uniformando la "vista" degli indirizzi in ram/cache/paging file etc) perchè dovrebbe essere indefinito il comportamento di un confronto tra entità che si potrebbero trattare come interi?

@Daniels: in effetti ci avevo sbadatamente pensato anche io allo stack che cresce verso il basso.