Teoricamente parlando funzioni C- come posso farlo?!

[9abs]

Salve,
ho bisogno di creare una funzione di confronto che da la possibilità di scegliere (come argomento) su diversi tipi di valori su cui fare il paragone.
Mi sorge la domanda di poter passare il valore come argomento VOID e poi all'interno della funzione cambiare il tipo di valore in base a quello scelto.
Questo per evitare di creare più funzioni per tipo che svolgono lo stesso compito.

Mi spiego meglio:
supponiamo che la funzione sia

struct confronto(struct s1,structs2, void * valore){
                
 //èpossibile passare il valore void qualunque esso sia il tipo fuori dalla funzione?
   //è possibile cambiare il tipo a Void valore qui all'interno per un corretto uso?
             

                return struct;
}

o devo per forza fare diverse funzioni per il confronto in base ai vari tipi?

Come sempre grazie per l'attenzione !

[misterx]

se ho capito bene, potresti farne anche una sola con tutti gli argomenti che desideri e semplicemente se non sono obbligatori

if(parametro100 == nulla) continua lo stesso

nn sos e ho reso l'idea.

Ovviamente se servono la strada è scriverne n.

[-MiStO-]

mhh non so se ho ben capito il problema, ma se invece di passare il valore passassi direttamente la funzione di confronto?

[pabloski]

Originariamente inviato da 9abs

Salve,
ho bisogno di creare una funzione di confronto che da la possibilità di scegliere (come argomento) su diversi tipi di valori su cui fare il paragone.
Mi sorge la domanda di poter passare il valore come argomento VOID e poi all'interno della funzione cambiare il tipo di valore in base a quello scelto.
Questo per evitare di creare più funzioni per tipo che svolgono lo stesso compito.

Mi spiego meglio:
supponiamo che la funzione sia

struct confronto(struct s1,structs2, void * valore){ == nulla) c
                
 //èpossibile passare il valore void qualunque esso sia il tipo fuori dalla funzione?
   //è possibile cambiare il tipo a Void valore qui all'interno per un corretto uso?
             

                return struct;
}

o devo per forza fare diverse funzioni per il confronto in base ai vari tipi?

Come sempre grazie per l'attenzione !

Brutta strada. Il C è famoso per i bug dovuti all'inconsistenza del suo modello di programmazione. E francamente tu stai cercando di arrivare ai limiti di quest'inconsistenza.

Void ovviamente accetta qualsiasi cosa. Sta lì apposta. Ma poi i confronti tra oggetti vanno sempre in maniera sensata.

Proprio dal punto di vista logico, potresti mai immaginare di confrontare una stringa con un intero? Avrebbe senso dal punto di vista logico? Ovviamente no.

Se la stringa è una stringa contenente un numero, allora la converti prima in numero e poi fai il confronto.

Per cui, a quella funzione manca un parametro che gli consente di capire l'oggetto d'origine di che tipo era. Dopo di che, una serie di if che fanno tutte le valutazioni e le conversioni del caso.

[9abs]

Grazie a tutti. Utilissimi .

[WarDuck]

Non è chiaro quanto generico dev'essere il metodo.

Ad esempio questo è un pezzo di un codice che avevo scritto per aggiungere un elemento ad una hash table (non riporto tutto il codice per compattezza, ma solo la parte che ci interessa):

int ph_add_generic(struct ph_table *h, void *value, size_t keyoff, size_t keylen)
{
    ...
    if (!memcmp(h->buckets[i] + keyoff, value + keyoff, keylen)) {
		/* element already present */
		return 1;
    }
    ...
}

Ad esempio l'elemento può essere una struct, passata genericamente attraverso il puntatore "value".

Il problema nelle hash table è determinare la "chiave" di cui fare l'hash, in questo caso specificata da 2 parametri:

- "keyoff" che rappresenta l'offset in bytes del campo all'interno della struttura e
- "keylen" che rappresenta quanto è lungo il campo

Il confronto avviene banalmente usando "memcmp" (non è il massimo dell'efficienza se vuoi fare un confronto per uguaglianza ma comunque era efficace e rapido nell'implementazione).

Tutto qui? No di certo. Usare la funzione generic direttamente è scomodo, così conviene scriversi degli helper, specialmente se il tipo di dato è noto a tempo di compilazione:

/** 
 * Add an element to hash table, using a field as a key.
 * @param table: hash table pointer.
 * @param eptr: pointer to the element (struct) to add.
 * @param keyfield: name of the field containing the key (size is computed
 * automatically)
 * @return 0: if element was added, 1: if already present, -1: if table is full.
 */ 
#define ph_add(table, eptr, keyfield) \
	ph_add_generic(table, eptr, offsetof(typeof(*eptr), keyfield), sizeof((*eptr).keyfield))

Qui c'è un po' di "magia nera" dovuta soprattutto all'uso della funzione "offsetof" che ti calcola l'offset di un campo in una struttura.

Quindi ad esempio:

struct pippo {
    int a;
    int b;
    char nome[15];
    char c;
};

struct pluto {
    short a;
    short b;
    int c;
    int d;
};

...

struct ph_table *tab = ph_init(..);
struct pippo x = { .. };
struct pluto y = { .. };

ph_add(tab, &x, nome); /* aggiungo alla hash table "x" usando come chiave il campo "nome" */
ph_add(tab, &y, c); /* aggiungo alla hash table "y" usando come chiave il campo "c" */

Chiaramente è solo un esempio, dipende tutto da quello che vuoi realizzare e con quale grado di genericità.