1 #include <string>

 2 #include <iostream>

 3

 4 class Screen {

 5 public:

 6     typedef std::string::size_type pos;

 7 #if defined(IN_CLASS_INITS) && defined(DEFAULT_FCNS)

 8     Screen() = default;  // needed because Screen has another constructor

 9 #else

10     Screen(): cursor(0), height(0), width(0) { }

11 #endif

12     // cursor initialized to 0 by its in-class initializer

13     Screen(pos ht, pos wd, char c): height(ht), width(wd),

14                                     contents(ht * wd, c) { }

15     friend class Window_mgr;

16     Screen(pos ht = 0, pos wd = 0):

17        cursor(0), height(ht), width(wd), contents(ht * wd, ' ') { }

18     char get() const              // get the character at the cursor

19         { return contents[cursor]; }       // implicitly inline

20     inline char get(pos ht, pos wd) const; // explicitly inline

21     Screen &clear(char = bkground);

22 private:

23     static const char bkground = ' ';

24 public:

25     Screen &move(pos r, pos c);      // can be made inline later

26     Screen &set(char);

27     Screen &set(pos, pos, char);

28     // other members as before

29     // display overloaded on whether the object is const or not

30     Screen &display(std::ostream &os)

31                   { do_display(os); return *this; }

32     const Screen &display(std::ostream &os) const

33                   { do_display(os); return *this; }

34 private:

35      // function to do the work of displaying a Screen

36      void do_display(std::ostream &os) const {os << contents;}

37     // other members as before

38 private:

39 #ifdef IN_CLASS_INITS

40     pos cursor = 0;

41     pos height = 0, width = 0;

42 #else

43     pos cursor;

44     pos height, width;

45 #endif

46     std::string contents;

47 };

48

49 Screen &Screen::clear(char c)

50 {

51     contents = std::string(height*width, c);

52     return *this;

53 }

54

55 inline                   // we can specify inline on the definition

56 Screen &Screen::move(pos r, pos c)

57 {

58     pos row = r * width; // compute the row location

59     cursor = row + c;    // move cursor to the column within that row

60     return *this;        // return this object as an lvalue

61 }

62

63 char Screen::get(pos r, pos c) const // declared as inline in the class

64 {

65     pos row = r * width;      // compute row location

66     return contents[row + c]; // return character at the given column

67 }

68

69 inline Screen &Screen::set(char c)

70 {

71     contents[cursor] = c; // set the new value at the current cursor location

72     return *this;         // return this object as an lvalue

73 }

74 inline Screen &Screen::set(pos r, pos col, char ch)

75 {

76     contents[r*width + col] = ch;  // set specified location to given value

77     return *this;                  // return this object as an lvalue

78 }

 1 #include <iostream>

 2 using std::cout; using std::endl;

 3

 4 #include <string>

 5 using std::string;

 6

 7 #include "Screen.h"

 8

 9 int main()

10 {

11     Screen myScreen(5,3);

12     // move the cursor to a given position, and set that character

13     myScreen.move(4,0).set('#');

14

15     Screen nextScreen(5, 5, 'X');

16     nextScreen.move(4,0).set('#').display(cout);

17     cout << "\n";

18     nextScreen.display(cout);

19     cout << endl;

20

21     const Screen blank(5, 3);

22     myScreen.set('#').display(cout);  // calls nonconst version

23     cout << endl;

24     blank.display(cout);              // calls const version

25     cout << endl;

26

27     myScreen.clear('Z').display(cout); cout << endl;

28     myScreen.move(4,0);

29     myScreen.set('#');

30     myScreen.display(cout); cout << endl;

31     myScreen.clear('Z').display(cout); cout << endl;

32

33     // if move returns Screen not Screen&

34     Screen temp = myScreen.move(4,0); // the return value would be copied

35     temp.set('#'); // the contents inside myScreen would be unchanged

36     myScreen.display(cout);

37     cout << endl;

38 }