Programmazione orientata agli oggetti: getter / setter o nomi logici

Sì, i getter / setter interrompono l'incapsulamento - sono fondamentalmente solo uno strato in più tra l'accesso diretto al campo sottostante. Potresti anche solo accedervi direttamente.

Ora, se vuoi che i metodi più complessi accedano al campo, è valido, ma invece di esporre il campo, devi pensare a quali metodi dovrebbe essere la classe invece di offrire. vale a dire. invece di una classe Bank con un valore Money esposto utilizzando una proprietà, è necessario pensare a quali tipi di accesso un oggetto Bank dovrebbe offrire (aggiungere denaro, prelevare, ottenere un saldo) e implementare quelli invece. Una proprietà sulla variabile Money è solo sintatticamente diversa dall'esporre direttamente la variabile Money.

DrDobbs ha un articolo che dice di più.

Per il tuo problema, avrei 2 metodi setStyle e clearStyle (o qualsiasi altra cosa) che prendono un enum dei possibili stili. Un'istruzione switch all'interno di questi metodi applicherebbe quindi i valori rilevanti alle variabili di classe appropriate. In questo modo, puoi cambiare la rappresentazione interna degli stili in qualcos'altro se in seguito decidi di memorizzarli come una stringa (per esempio in HTML) - qualcosa che richiederebbe a richiedere la modifica di tutti gli utenti della classe anche se hai utilizzato le proprietà get / set.

È ancora possibile attivare stringhe se si desidera prendere valori arbitrari, avere una dichiarazione if-then di grandi dimensioni (se ce ne sono alcune) o una mappa di valori stringa per i puntatori del metodo utilizzando std :: mem_fun (o std :: function ) così" bold "verrebbe memorizzato in una chiave map con il suo valore sts :: mem_fun in un metodo che imposta la variabile bold su true (se le stringhe sono lo stesso dei nomi delle variabili membro, quindi puoi anche utilizzare la stringa di stringhe per ridurre la quantità di codice devi scrivere)

Un'idea che potresti non aver preso in considerazione è il pattern Decorator . Piuttosto che impostare i flag in un oggetto e quindi applicare tali flag a qualsiasi cosa tu stia scrivendo, puoi avvolgere la classe che fa la scrittura in Decorators, che a sua volta applica gli stili.

Il codice chiamante non ha bisogno di sapere quanti di questi wrapper hai messo intorno al tuo testo, basta chiamare un metodo sull'oggetto esterno e richiama lo stack.

Per un esempio pseudocodice:

class TextWriter : TextDrawingInterface {
    public:
        void WriteString(string x) {
            // write some text somewhere somehow
        }
}

class BoldDecorator : TextDrawingInterface {
    public:
        void WriteString(string x) {
            // bold application on
            m_textWriter.WriteString(x);
            // bold application off
        }

        ctor (TextDrawingInterface textWriter) {
            m_textWriter = textWriter;
        }

    private:
        TextWriter m_TextWriter;
}

E così via, per ogni stile di decorazione. Nel suo utilizzo più semplice, puoi quindi dire

TextDrawingInterface GetDecoratedTextWriter() {
    return new BoldDecorator(new ItalicDecorator(new TextWriter()));
}

E il codice che chiama questo metodo non ha bisogno di conoscere i dettagli di ciò che sta ricevendo. Finché è QUALCOSA che può disegnare il testo attraverso un metodo WriteString.

Mi piacerebbe la seconda soluzione. Sembra più elegante e flessibile. Sebbene sia difficile immaginare altri tipi oltre che grassetto, corsivo e sottolineato (overline?), Sarebbe difficile aggiungere nuovi tipi usando le variabili membro.

Ho usato questo approccio in uno dei miei ultimi progetti. Ho una classe che può avere più attributi booleani. Il numero e i nomi degli attributi possono cambiare nel tempo. Li memorizzo in un dizionario. Se un attributo non è presente, suppongo che il suo valore sia "falso". Devo anche memorizzare un elenco di nomi di attributi disponibili, ma questa è un'altra storia.

Penso che tu stia pensando troppo al problema.

styles.setBold(true) e styles.setItalic(false) sono OK