1. #include <stdio.h>
2. #include <conio.h>
3. #include <malloc.h>
4. #include <string.h>
5.  
6. // operator >> ma przesuwaæ nasz tekst o okreœlon¹ iloœæ miejsc, ma siê odbywaæ rotacja w kó³ko
7. // wyœwiatlane ma byæ 10 ostatnich liter napisu
8.  
9. class String
10. {
11.         public:
12.                 String(const int);
13.                 ~String();
14.  
15.                 String& operator += (const char *str);
16.                 String& operator >> (int x);
17.                 String& operator << (int x);
18.  
19.                 bool operator == (const String& str) const;
20.                 bool operator != (const String& str) const;
21.  
22.                 char* getString() const;
23.  
24.         private:
25.                 char *string;
26.                 unsigned int position, n;
27. };
28.  
29. String::String(const int n = 64)
30. {
31.         this->string = NULL;
32.         this->n = 0;
33.         this->position = 0;
34.         if(n > 0)
35.         {
36.                 this->string = (char*)malloc((n+1)*sizeof(char));
37.                 if(this->string)
38.                 {
39.                         this->n = n;
40.                         for(unsigned int i = 0; i < n+1; i++)
41.                         {
42.                                 if(n == i)
43.                                 {
44.                                         this->string[n] = '\0';
45.                                 }
46.                                 else
47.                                 {
48.                                         this->string[i] = ' ';
49.                                 }
50.                         }
51.                 }
52.         }
53. }
54.  
55. String::~String()
56. {
57.         if(string != NULL)
58.         {
59.                 free(string);
60.         }
61. }
62.  
63. String& String::operator += (const char *str)
64. {
65.         if(position != n)
66.         {
67.                 unsigned int size = strlen(str);
68.                 if(position + size < n)
69.                 {
70.                         for(unsigned int i = position, x = 0; i < size + position; i++, x++)
71.                         {
72.                                 string[i] = str[x];
73.                         }
74.                         position += size;
75.                 }
76.                 else
77.                 {
78.                         unsigned int max = size - (n - position);
79.                         for(unsigned int i = position; i < n; i++)
80.                         {
81.                                 if(str[max] == '\0')
82.                                         break;
83.  
84.                                 string[i] = str[max];
85.                                 max++;
86.                         }
87.                         position = n;
88.                 }
89.         }
90.         return *this;
91. }
92.  
93. bool String::operator == (const String& str) const
94. {
95.         return (strcmp(this->string, str.string) != 0) ? false : true;
96. }
97.  
98. bool String::operator != (const String& str) const
99. {
100.         return (strcmp(this->string, str.string) == 0) ? false : true;
101. }
102.  
103. String& String::operator >> (int x)
104. {
105.         if(x > 0)
106.         {
107.                 while(x > 0)
108.                 {
109.                         char copy = string[n-1];
110.  
111.                         for(unsigned int i = n-1; i > 0; i--)
112.                         {
113.                                 string[i] = string[i-1];
114.                         }
115.                         string[0] = copy;
116.                         --x;
117.                 }
118.         }
119.         return *this;
120. }
121.  
122. String& String::operator << (int x)
123. {
124.         if(x > 0)
125.         {
126.                 while(x > 0)
127.                 {
128.                         char copy = string[0];
129.  
130.                         for(unsigned int i = 0; i < n-1; i++)
131.                         {
132.                                 string[i] = string[i+1];
133.                         }
134.                         string[n-1] = copy;
135.                         --x;
136.                 }
137.         }
138.         return *this;
139. }
140.  
141. char* String::getString() const
142. {
143.         return string;
144. }
145.  
146. int main()
147. {
148.         String Wiersz1;
149.         String Wiersz2(64);
150.  
151.         printf("Wiersz1: %s \n", Wiersz1.getString());
152.         printf("Wiersz2: %s \n\n", Wiersz2.getString());
153.  
154.         Wiersz1 += "To jest pierwszy wiersz";
155.         Wiersz2 += "To jest pierwszy wiersz";
156.  
157.         printf("Wiersz1: %s \n", Wiersz1.getString());
158.         printf("Wiersz2: %s \n", Wiersz2.getString());
159.  
160.         if(Wiersz1 == Wiersz2)
161.         {
162.                 printf("Wiersze sa identyczne. \n\n");
163.         }
164.  
165.         Wiersz2 += ". To jednak drugi!";
166.         printf("Wiersz1: %s \n", Wiersz1.getString());
167.         printf("Wiersz2: %s \n", Wiersz2.getString());
168.  
169.         if(Wiersz1 != Wiersz2)
170.         {
171.                 printf("Wiersze sa rozne od siebie. \n\n");
172.         }
173.  
174.         Wiersz2 += " I to wszystko co wiemy.";
175.         printf("Wiersz1: %s \n", Wiersz1.getString());
176.         printf("Wiersz2: %s \n\n", Wiersz2.getString()); // W przypadku braku miejsca mialo liczyc od konca, wiec wywalamy z poczatku
177.  
178.         Wiersz1 >> (5);
179.         Wiersz2 >> (5);
180.  
181.         printf("Wiersz1: %s \n", Wiersz1.getString());
182.         printf("Wiersz2: %s \n", Wiersz2.getString());
183.  
184.         Wiersz1 << (2);
185.         Wiersz2 << (2);
186.  
187.         printf("Wiersz1: %s \n", Wiersz1.getString());
188.         printf("Wiersz2: %s \n", Wiersz2.getString());
189.  
190.         _getch();
191.         return 0;
192. }