Advertisement
Guest User

Hello, World

a guest
Jan 18th, 2018
96
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 5.13 KB | None | 0 0
  1. #include "stdafx.h"
  2. #include <iostream>
  3. #include <vector>
  4. #include <algorithm>
  5. #include <functional>
  6. #include <cassert>
  7. void displayMessage();
  8. enum ESentenceType {
  9.     eStatement,
  10.     eExclamation,
  11.     sQuestion,
  12.     eCommand
  13. };
  14. class nonCopyable {
  15. protected:
  16.     nonCopyable() {
  17.     }
  18.     ~nonCopyable() {
  19.     }
  20. private:
  21.     nonCopyable(const nonCopyable&);
  22.     const nonCopyable& operator=(const nonCopyable&);
  23. };
  24. inline char getPunctionMark(ESentenceType sentenceType) {
  25.     char puncMark = '.';
  26.     switch (sentenceType) {
  27.     case eStatement: puncMark = '.'; break;
  28.     case eExclamation: puncMark = '!'; break;
  29.     case sQuestion: puncMark = '?'; break;
  30.     case eCommand: puncMark = '.'; break;
  31.     default: {
  32.         assert(false);
  33.     }
  34.     }
  35.     return puncMark;
  36. }
  37. template<typename TElem>
  38. class Creatable {
  39. protected:
  40.     Creatable() {
  41.     }
  42.     virtual ~Creatable() {
  43.         clear();
  44.     }
  45. public:
  46.     static TElem* create() {
  47.         TElem* e = new TElem;
  48.         return e;
  49.     }
  50.     void free() {
  51.         delete this;
  52.     }
  53.     virtual void clear() {
  54.     }
  55. };
  56. template<typename TElem, typename TParam>
  57. class CreatableParam {
  58. protected:
  59.     CreatableParam() {
  60.     }
  61.     virtual ~CreatableParam() {
  62.     }
  63. public:
  64.     static TElem* create(TParam p) {
  65.         TElem* e = new TElem;
  66.         e->initialize(p);
  67.         return e;
  68.     }
  69.     void free() {
  70.         finalize();
  71.         delete this;
  72.     }
  73.     virtual void initialize(TParam /*p*/) {
  74.     }
  75.     virtual void finalize() {
  76.         clear();
  77.     }
  78.     virtual void clear() {
  79.     }
  80. };
  81. class DisplayElem
  82.     : public nonCopyable {
  83. protected:
  84.     DisplayElem() {
  85.     }
  86.     virtual ~DisplayElem() {
  87.     }
  88. public:
  89.     virtual void display(std::ostream& os) const = 0;
  90. };
  91. class Displayer
  92.     : public std::unary_function<void, const DisplayElem*> {
  93. private:
  94.     std::ostream& m_os;
  95.     char   m_sep;
  96.     size_t m_count;
  97. public:
  98.     Displayer(std::ostream& os, char sep = '\0')
  99.         : m_os(os)
  100.         , m_sep(sep)
  101.         , m_count(0) {
  102.     }
  103.     ~Displayer() {
  104.     }
  105.     void operator()(const DisplayElem* e) {
  106.         if (('\0' != m_sep) && (0 < m_count)) {
  107.             m_os << m_sep;
  108.         }
  109.         e->display(m_os);
  110.         ++m_count;
  111.     }
  112. };
  113. template <typename TElem>
  114. class Freer
  115.     : public std::unary_function<void, TElem*> {
  116. public:
  117.     void operator()(TElem* e) {
  118.         e->free();
  119.     }
  120. };
  121. class Letter
  122.     : public DisplayElem
  123.     , public CreatableParam<Letter, char> {
  124. private:
  125.     char m_ch;
  126.  
  127. protected:
  128.     ~Letter() {
  129.     }
  130. public:
  131.     Letter() : m_ch('\0') {
  132.     }
  133.     void initialize(char ch) {
  134.         m_ch = ch;
  135.     }
  136.     void finalize() {
  137.         m_ch = '\0';
  138.     }
  139.     void display(std::ostream& os) const {
  140.         os << m_ch;
  141.     }
  142. };
  143. class Word
  144.     : public DisplayElem
  145.     , public Creatable<Word> {
  146. private:
  147.     std::vector<Letter*> m_letters;
  148.  
  149. protected:
  150.     ~Word() {
  151.         clear();
  152.     }
  153.  
  154. public:
  155.     Word() {
  156.     }
  157.     void clear() {
  158.         std::for_each(m_letters.begin(), m_letters.end(), Freer<Letter>());
  159.         m_letters.clear();
  160.     }
  161.     void addLetter(Letter* s) {
  162.         m_letters.push_back(s);
  163.     }
  164.     void display(std::ostream& os) const {
  165.         std::for_each(m_letters.begin(), m_letters.end(), Displayer(os));
  166.     }
  167. };
  168. class Sentence
  169.     : public DisplayElem
  170.     , public CreatableParam<Sentence, ESentenceType> {
  171. private:
  172.     std::vector<Word*> m_words;
  173.     ESentenceType m_sentenceType;
  174. protected:
  175.     ~Sentence() {
  176.         clear();
  177.     }
  178.     void endSentence(std::ostream& os) const {
  179.         const char puncMark = getPunctionMark(m_sentenceType);
  180.         os << puncMark;
  181.     }
  182. public:
  183.     Sentence()
  184.         : m_sentenceType(eStatement) {
  185.     }
  186.     void initialize(ESentenceType sentenceType) {
  187.         m_sentenceType = sentenceType;
  188.     }
  189.     void finalize() {
  190.         m_sentenceType = eStatement;
  191.     }
  192.     void clear() {
  193.         std::for_each(m_words.begin(), m_words.end(), Freer<Word>());
  194.         m_words.clear();
  195.     }
  196.     void addWord(Word* w) {
  197.         m_words.push_back(w);
  198.     }
  199.     void display(std::ostream& os) const {
  200.         std::for_each(m_words.begin(), m_words.end(), Displayer(os, ' '));
  201.         endSentence(os);
  202.     }
  203. };
  204. class Message
  205.     : public DisplayElem
  206.     , public Creatable<Message> {
  207. private:
  208.     std::vector<Sentence*> m_sentences;
  209. protected:
  210.     ~Message() {
  211.         clear();
  212.     }
  213.     void endMessage(std::ostream& os) const {
  214.         os << std::endl;
  215.     }
  216. public:
  217.     Message() {
  218.     }
  219.     void clear() {
  220.         std::for_each(m_sentences.begin(), m_sentences.end(), Freer<Sentence>());
  221.         m_sentences.clear();
  222.     }
  223.     void addSentence(Sentence* s) {
  224.         m_sentences.push_back(s);
  225.     }
  226.     void display(std::ostream& os) const {
  227.         std::for_each(m_sentences.begin(), m_sentences.end(), Displayer(os, ' '));
  228.         endMessage(os);
  229.     }
  230. };
  231. int main() {
  232.     displayMessage();
  233.     return 0;
  234. }
  235. void displayMessage() {
  236.     Word* first_word = Word::create();
  237.     first_word->addLetter(Letter::create('H'));
  238.     first_word->addLetter(Letter::create('e'));
  239.     first_word->addLetter(Letter::create('l'));
  240.     first_word->addLetter(Letter::create('l'));
  241.     first_word->addLetter(Letter::create('o'));
  242.     Word* second_word = Word::create();
  243.     second_word->addLetter(Letter::create('w'));
  244.     second_word->addLetter(Letter::create('o'));
  245.     second_word->addLetter(Letter::create('r'));
  246.     second_word->addLetter(Letter::create('l'));
  247.     second_word->addLetter(Letter::create('d'));
  248.     Sentence* sentence = Sentence::create(eExclamation);
  249.     sentence->addWord(first_word);
  250.     sentence->addWord(second_word);
  251.     Message* message = Message::create();
  252.     message->addSentence(sentence);
  253.     message->display(std::cout);
  254.     message->free();
  255. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement