punto a chi punta a complicarmi la puntata

Premetto che di quello che sto per chiedere non ne capisco una parola, ergo potrebbe essere tutto sbagliato.
Presupposti fondamentali:
1)Per svago, e per cercare di impararci qualcosa, sto cominciando a pensare di scrivere una libreria che renda le stringhe facili come le String, senza il problema dell'allocazione dinamica ovviamente. SO che tutte le funzioni che lo fanno esistono già, e che esiste anche una libreria che permette di usare la .print sulle stringhe, che più facile di così... ma voglio complicarmi la vita.
1.1)Stando al momento solo a livello teorico sto pensando alle funzioni che aggiungono ad una stringa un numero. La strada canonica, credo, sarebbe scrivere una funzione per ogni tipo di numero (chiaramente char e float esclusi, essendo differenti come uso e significato), e questo richiederebbe 5 funzioni molto simili
2)Pur di non scrivere 5 funzioni molto simili mi complico la vita parecchio
3)Ho conosciuto, o per meglio dire so che esistono i puntatori, che mi paiono molto interessanti
3.1) mi pare di aver capito che esistono i puntatori a null, e che me li sono figurati come dei "puntatori a te lo dico dopo"

Di conseguenza ho pensato che, per evitare questo, si potrebbe fare che alla funzione, al posto del numero potrebbe essere passato un puntatore a null, che però punta al primo byte del numero, ed una variabile che, in un mio codice arbitrario, indica di che tipo sarà il puntatore, ovvero a che tipo di variabile punta. (0=byte 1=int 2= unsigned int ...)
Nella funzione, all'inizio, con una switch case in base alla variabile rendo il puntatore a null un puntatore a quello che deve, e poi in tutto il resto della funzione opero sul puntato.
La cosa sarebbe così

//da qualche parte
{
byte variabilechevoglio=suovalore;
byte copiadivariabilechevoglio=variabilechevoglio;//lavorando con un puntatore devo puntare ad una copia
//creo un puntatore a nulla
//lo faccio puntare a copiadivariabilechevoglio, ma senza dirgliene il tipo (si può fare???)
Funzionechescriveinumerinellestringhe (..., puntatorecreato, 0);//0=codice arbitrario per variabili byte
//cose
}
bool Funzionechescriveinumerinellestringhe (..., puntatoreanull puntatore, byte tipo)
{
switch (tipo)
{
case 0:
//Ora gli dico che puntatore punta a byte
break;
case 1:
...
}
//esempio
stringapassata [indiceottenuto]=numeropuntatodalpuntatore%base;
numeropuntatodalpuntatore/=base;
}

Poi mi son chiesto "Potrei pensarla peggio" Ecco cosa mi son risposto: Tutta la switch case potrebbe essere una funzione a parte, alla quale magari passare il puntatore al puntatore a null e il codice arbitrario del tipo. In questa funzione trasformerei, in base alla stessa switch case, il puntato del puntatore al puntatore a null (ovvero il puntatore a null) in un puntatore a qualcosa, ovvero a quello che deve puntare.

La cosa è fattibile? Vanno aggiunti puntatori a puntatori? Devo puntare a buttarla via?

Silente:
... un puntatore a null, che però punta al primo byte del numero...

Mi sono fermato a questa frase e non riesco più ad andare avanti.
Io non sono molto pratico di puntatori, per cui forse mi sbaglio, ma che senso ha passare un puntatore a null?
O meglio non trovo il senso di prevedere che un parametro di una funzione sia un puntatore e venga passato sempre a null.
Perchè in certi casi può avere senso passare un puntatore a null, in quei casi la funzione non lo usera per lavorarci ma per verificarlo ed eventualmente fare altro.

Nel metodo classico le funzioni non sarebbero quasi uguali ma avrebbero solo lo stesso nome.
Ad es. quella che accoda un byte farà il lavoro di accodamento, quella che accoda un int spezzerà l'int in due byte e chiamerà due volte quella che accoda un byte...

Un puntatore a null non è un puntatore che punterà in futuro ma è un indirizzo di memoria dedicato a contenere un dato che ti serve (l'indirizzo del primo byte del dato), poi questo dato può esserci già o venire scritto successivamente.
Però o lo scrivi dentro alla funzione o sei in multi threading e aspetti che altri lo scrivano prima di uscire dalla tua funzione... altrimenti è come passare il parametro.
La vera differenza tra passare un parametro o un puntatore al parametro è che nel primo caso accedi ad una copia del valore, mentre nel secondo accedi al valore originario. Nel primo caso se modifichi il valore non ha effetto fuori della funzione, nel secondo caso si.

Ho capito male quello che hai scritto?
Sono andato fuori tema?

Non è un puntatore NULL ma un puntatore di tipo void* p che può essere convertito poi in qualsiasi tipo
di puntatore. Ma penso che poi dovrai avere i vari puntatori ai vari tipi, ti crei una funzione che fa cose diverse ma composta da più codice. Quindi non è molto diverso da avere più funzioni, in C++ esiste
overloading dei metodi, più metodi con lo stesso nome ma con parametri diversi, io credo sia questa la strada da seguire. :slight_smile: :slight_smile:

Grazie ad entrambi. So che era un'idea strana, e che la forma canonica é fare overload di funzioni, ma pensavo a qualcosa di più strano.
Per maubarzi, nessun fuori tema, anzi.