Classe StringaAllineata

Di seguito intestazione e implementazione della classe StringaAllineata scritta durante la lezione del 23 aprile 2013.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#ifndef STRINGA_ALLINEATA_H
#define STRINGA_ALLINEATA_H
 
#include <string>
#include <ostream>
 
using namespace std;
 
class StringaAllineata : public string {
    friend ostream& operator<<(ostream& out, const StringaAllineata& s);
public:
    enum Allineamento { SINISTRA = 0, DESTRA, CENTRATO, GIUSTIFICATO };
 
    StringaAllineata();
    StringaAllineata(Allineamento all);
    StringaAllineata(const string& str, Allineamento all);
 
    Allineamento getAllineamento() const;
    void setAllineamento(Allineamento value);
 
    int contaSpazi() const;
 
private:
    Allineamento allineamento;
 
    static int larghezza;
};
 
#endif
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
#include "StringaAllineata.h"
 
#include <cassert>
 
int StringaAllineata::larghezza = 80;
 
ostream& operator<<(ostream& out, const StringaAllineata& s) {
    switch(s.getAllineamento()) {
    case StringaAllineata::SINISTRA:
        //out << s; // MALE
        //out << s.c_str();
        out << static_cast<string>(s);
        break;
 
    case StringaAllineata::DESTRA:
        for(int i = s.length(); i < StringaAllineata::larghezza; i++)
            out << ' ';
        out << static_cast<string>(s);
        break;
 
    case StringaAllineata::CENTRATO:
        for(int i = ( StringaAllineata::larghezza - s.length() ) / 2; i > 0; i--)
            out << ' ';
        out << static_cast<string>(s);
        break;
 
    case StringaAllineata::GIUSTIFICATO:
        int daAggiungere = StringaAllineata::larghezza - s.length();
        int spaziBianchi = s.contaSpazi();
        int count = 0;
        for(int i = 0; i < s.length(); i++) {
            out << s.c_str()[i];
            if(s.c_str()[i] == ' ') {
                assert(spaziBianchi > 0);
                for(int j = 0; j < daAggiungere / spaziBianchi; j++)
                    out << ' ';
                if(count < daAggiungere % spaziBianchi)
                    out << ' ';
                count++;
            }
        }
 
        break;
    }
    return out << endl;
}
 
StringaAllineata::StringaAllineata()
: string(), allineamento(SINISTRA) {
}
 
StringaAllineata::StringaAllineata(Allineamento all)
: string(), allineamento(all) {
}
 
StringaAllineata::StringaAllineata(const string& str, Allineamento all)
: string(str), allineamento(all) {
}
 
StringaAllineata::Allineamento StringaAllineata::getAllineamento() const {
    return allineamento;
}
 
void StringaAllineata::setAllineamento(Allineamento value) {
    allineamento = value;
}
 
int StringaAllineata::contaSpazi() const {
    int count = 0;
    for(int i = 0; i < length(); i++)
        if(c_str()[i] == ' ')
            count++;
    return count;
}
Challange! Implementare una classe Paragrafo che gestisca un gruppo di linee. Meglio la composizione o l’ereditariet√†?

Leave a Reply

Your email address will not be published. Required fields are marked *