tipo la stringa di un tipo che non stringa........

Cioe': un tipo di stringa di una varietà che non mi strizzi (i gioielli di famiglia) Purtroppo io non so programmare in C++, lo ho sempre detto e come tutti sappiamo gli oggetti stringa del CPP sono delle belle polpette avvelenate per noi poveri arduinisti mi è quindi venuto l'uzzolo di imparare il C++ dalla parte più difficile: scrivere una libreria di oggetti stringa che NON usi l'allocazione dinamica (e che quindi abbia una dimensione definita a compile-time) ora, non sapendo programmare in C++ e avendo appena cominciato mi sono fatto due o tre cosette piuttosto pericolose, nel senso che volutamente ho ignorato i controlli di sbordamento al di fuori di un array, lo so che vanno fatti, ma per provare va bene così ho fatto una cosa del genere: Classe:

class Sequenza
{

    public:
        // costruttore

        Sequenza(char * stringa = "");
        Sequenza(Sequenza & stringa);


        // operatori
        Sequenza & operator + (Sequenza & seconda);


        char spazio[TAGLIA];    // l'array di caratteri (coincide con una stringa di 'C'
        ~Sequenza(void);
    protected:
        byte dimensione;     // la lunghezza (meno 1, per lo spazio del terminatore)
        byte lunghezza;      // coincide con la ansi C strlen()

        Sequenza & Sequenza::copy(char stringa[], unsigned int lun);
        void Sequenza::init(void);

};

invece che stringa la ho chiamata Sequenza, che fantasia vero? naturalmente TAGLIA è una macro che mi permette di definire la dimensione desiderata come vedete ho previsto per il momento un solo operatore, la concatenazione e così ho messo il codice che fa il lavoro sporco

Sequenza::Sequenza(char stringa[])
{
    init();
    copy(stringa, strlen(stringa));
    lunghezza = strlen(this->spazio);
}

Sequenza::Sequenza(Sequenza & stringa)
{
    init();

    for (byte i = 0; i < TAGLIA; i++)
    {
        this->spazio[i] = stringa.spazio[i];
    }

    lunghezza = strlen(this->spazio);
}

void Sequenza::init(void)
{
    for (byte i = 0; i < TAGLIA; i++)
    {
        spazio[i] = 0;
    }

    dimensione = TAGLIA;
    lunghezza = 0;
}

Sequenza & Sequenza::copy(char stringa[], unsigned int lun)
{
    lunghezza = lun;
    strcpy(spazio, stringa);
    return *this;
}

Sequenza::~Sequenza(void)
{
    // nulla da fare
}

Sequenza & Sequenza::operator+ (Sequenza & seconda)
{
    byte index = this->lunghezza;
    byte i = 0;

    while (seconda.spazio[i])
    {
        this->spazio[index + i] = seconda.spazio[i++];
        this->spazio[index + i] = 0;
    }

    this->lunghezza = index + i;
    return *this;
}

e il programma principale

Sequenza prova;
void setup(void)
{
    Serial.begin(9600);
}

void loop(void)
{
    Serial.println("Avviato");
    prova = "Amoco ";
    Sequenza dettaglio ;
    dettaglio = "Haven";
    prova = prova + dettaglio;
    Sequenza nome = prova;
    Serial.println(nome.spazio);
    delay(500);
}

come vedete posso definire sia variabili globali che locali, e ho provato l'operatore + e funziona però non capisco come posso mandare in stampa direttamente l'oggetto e non il suo elemento io vorrei poter fare

Serial.println(prova);

invede adesso sono costretto a fare:

Serial.println(prova.spazio);

dove l'elemento spazio è un array di caratteri ora la domanda: è possibile fare ciò che voglio? mi manca qualcosa che non so? oppure sarò costretto a prevedere un'ulteriore overloading, questa volta dentro nella println? per il momento buona notte a tutti voi e, data la brutta cronaca odierna: VIVE LA FRANCE, VIVE LA LIBERTE' dai, tutti in coro, mostriamoci uniti

Ciao! Neanche io conosco il C++, se hai intenzione di approfondire il linguaggio mi sembra una cosa positiva! :) Se consideriamo questa classe come esercizio per imparare il C++ SONO FAVOREVOLE :) Se invece la valutiamo come alternativa alle stringhe del C a mio parere non ha motivo di esistere, la libreria standard del C forniste tutte le funzioni necessarie Ripeto non conosco il C++ ma penso che un oggetto che "contenga al suo interno" tutti i metodi occupi più memoria rispetto a quello che facciamo col C, ripeto non sono sicuro ma penso sia cosi.

"Esercizio" sicuramente utile...però ti informo che esiste già una libreria PString che rendere un array di char gestibile un po' come una String

Oh no, conosco la pstring, il mio è solo un esercizio, dai miei post si vede che uso spesso le funzioni standard di c, Puro esercizio, spero di imparare qualcosa, e spero di non essere importuno parlandone qui è cercando suggerimenti

Dal punto di vista della programmazione ad oggetti i membri che contengono i dati da memorizzare dovrebbero sempre essere "nascosti" e quindi non public. L'accesso quindi a questi dati devono avvenire tramite funzioni/operatori opportunamente costruiti (incapsulamento) Quindi avere l'array pubblico è molto "brutto"

mi rendo pienamente conto, e lo sapevo anche... ma come detto muovo i primi passi in questa direzione mi rimane la domanda primeva: ma quindi devo per forza di cose modificare la print() se voglio farle stampare il contenuto dell'oggetto? temo di sì, ma è un po' una delusione.........

Si se vuoi usare il sistema "Arduino" di oggetti ed ereditarietà delle classi steam/print