読者です 読者をやめる 読者になる 読者になる

進捗状況

演算子多重定義関数 !=,==,=,+,+=を実装した。
ソースコード
MCString.h

// MCString.h: MCString クラスのインターフェイス
//
//////////////////////////////////////////////////////////////////////

#if !defined(AFX_MCSTRING_H__ECDC3D64_8C25_4A6A_9CF9_783906817F0B__INCLUDED_)
#define AFX_MCSTRING_H__ECDC3D64_8C25_4A6A_9CF9_783906817F0B__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

class MCString  
{
public:
	/** 文字列の実体を返す */
	char* getter();
	/** Stringの実体が入る */
	char* m_String;

	MCString( char* string );
	MCString();
	
	virtual ~MCString();
	//演算子多重定義
	MCString& operator=(char* string);
	MCString& operator=( MCString& s );
	MCString operator+(char* string);
	MCString operator+( MCString &s );
	friend MCString operator+( char* string, MCString& s );
	MCString& operator+=( char* string );
	MCString& operator+=( MCString& s );
	int operator==( char* string );
	int operator==( MCString &s );
	friend int operator==( char* string, MCString& s );
	int operator!=( char* string );
	int operator!=( MCString &s );
	friend int operator!=( char* string, MCString& s );
	operator char*() {return m_String; };
private:
	/** Stringの実体の文字列の長さ */
	unsigned int m_Len;
};

#endif // !defined(AFX_MCSTRING_H__ECDC3D64_8C25_4A6A_9CF9_783906817F0B__INCLUDED_)

MCString.cpp

  1  // MCString.cpp: MCString クラスのインプリメンテーション
  2  // CStringみたいなのを、Linuxでも動作できるようにしたい....
  3  //////////////////////////////////////////////////////////////////////
  4
  5  #include "MCString.h"
  6  #include <stdlib.h>
  7  #include <string.h>
  8  #include <stdio.h>
  9
 10  //////////////////////////////////////////////////////////////////////
 11  // 構築/消滅
 12  //////////////////////////////////////////////////////////////////////
 13
 14  MCString::MCString()
 15  {
 16
 17  }
 18
 19  MCString::~MCString()
 20  {
 21      delete []this->m_String;
 22  }
 23
 24  /**コンストラクタ.
 25   * データ付でクラス宣言する.
 26   * @param string 入れる文字.
 27   */
 28  MCString::MCString(char *string)
 29  {
 30      if ( *string ) {
 31          int iLen = strlen( string );
 32          char* lpac = (char*)malloc( iLen + 1 );
 33          strcpy( lpac, string );
 34          this->m_String = lpac;
 35          this->m_Len    = strlen( this->m_String );
 36      //  printf("in MCString(char*) = |%s|\n", this->m_String);
 37      } else {
 38          this->m_String = NULL;
 39          this->m_Len    = 0;
 40      }
 41   }
 42
 43  /** MCStringの実体を取得する.
 44   * @return 実体を返す
 45   */
 46  char* MCString::getter()
 47  {
 48      return this->m_String;
 49  }
 50
 51  MCString& MCString::operator=(char *string)
 52  {
 53  //  char* prev = this->m_String;
 54
 55      if ( string ) {
 56          int iLen = strlen( string );
 57          char* lpac = (char*)malloc( iLen + 1 );
 58          strcpy( lpac, string );
 59          this->m_String = lpac;
 60          this->m_Len    = strlen( this->m_String );
 61      } else {
 62          this->m_String = NULL;
 63          this->m_Len = 0;
 64      }
 65      return *this;
 66  }
 67
 68
 69  MCString MCString::operator +( char *string )
 70  {
 71  //  char* prev = this->m_String;
 72      if ( string ) {
 73          int iLen1 = strlen( this->m_String );
 74          int iLen2 = strlen( string );
 75          int iLen = iLen1 + iLen2;
 76          char* lpac = (char*)malloc( iLen + 1 );
 77          strcpy( lpac, this->m_String );
 78          strcat( lpac, string );
 79          return MCString( lpac );
 80      } else {
 81          return MCString();
 82      }
 83  }
 84
 85  MCString operator +( char* string, MCString &s ) {
 86      if ( s.m_String ) {
 87          int iLen1 = strlen( string );
 88          int iLen2 = strlen( s.m_String );
 89          int iLen = iLen1 + iLen2;
 90          char* lpac = (char*)malloc( iLen + 1 );
 91          strcpy( lpac, string );
 92          strcat( lpac, s.m_String );
 93          return MCString( lpac );
 94      } else {
 95          return MCString();
 96      }
 97  }
 98
 99
100  MCString MCString::operator +( MCString &s )
101  {
102      if (s.m_String) {
103          int iLen1 = strlen( this->m_String );
104          int iLen2 = strlen( s.m_String );
105          int iLen = iLen1 + iLen2;
106          char* lpac = (char*)malloc( iLen + 1 );
107          strcpy( lpac, this->m_String );
108          strcat( lpac, s.m_String );
109          return MCString( lpac );
110      } else {
111          return MCString();
112      }
113  }
114
115
116  MCString& MCString::operator =(MCString& s)
117  {
118  //  char* prev = this->m_String;
119      if (s.m_String) {
120          int iLen = s.m_Len;
121          char* lpac = ( char* )malloc( iLen + 1 );
122          strcpy( lpac, s.m_String );
123          this->m_String = lpac;
124          this->m_Len    = iLen;
125      } else {
126          this->m_String = NULL;
127          this->m_Len = 0;
128      }
129      return *this;
130  }
131
132
133  MCString& MCString::operator +=(char *string)
134  {
135      if (this->m_String) {
136          if ( string ) {
137              int iLen1 = strlen( this->m_String );
138              int iLen2 = strlen( string );
139              int iLen = iLen1 + iLen2;
140              char* lpac = ( char* )malloc( iLen + 1 );
141              strcpy( lpac, this->m_String );
142              strcat( lpac, string );
143              this->m_String = lpac;
144              this->m_Len     = iLen;
145          }
146      } else {
147          if ( string ) {
148              int iLen = strlen( string );
149              char* lpac = (char*)malloc( iLen + 1 );
150              strcpy( lpac, string );
151              this->m_String = lpac;
152              this->m_Len = iLen;
153          } else {
154              this->m_Len = 0;
155              this->m_String = NULL;
156          }
157      }
158      return *this;
159  }
160
161  MCString& MCString::operator +=(MCString &s)
162  {
163      if (this->m_String) {
164          if ( s.m_String ) {
165              int iLen1 = strlen( this->m_String );
166              int iLen2 = strlen( s.m_String );
167              int iLen = iLen1 + iLen2;
168              char* lpac = (char*)malloc( iLen + 1 );
169              strcpy( lpac, this->m_String );
170              strcat( lpac, s.m_String );
171              this->m_String = lpac;
172              this->m_Len = iLen;
173          }
174      } else {
175          if ( s.m_String ) {
176              int iLen = strlen( s.m_String );
177              char* lpac = (char*)malloc( iLen + 1 );
178              strcpy( lpac, s.m_String );
179              this->m_String = lpac;
180              this->m_Len = iLen;
181          } else {
182              this->m_Len = 0;
183              this->m_String = NULL;
184          }
185      }
186      return *this;
187  }
188
189  int MCString::operator ==(char *string)
190  {
191      if (!strcmp( this->m_String, string )) {
192          //一致している
193          return 1;
194      } else {
195          //一致していない
196          return -1;
197      }
198  }
199
200  int MCString::operator ==(MCString &s)
201  {
202      if ( !strcmp( this->m_String, s.m_String ) )     {
203          //一致
204          return 1;
205      } else {
206          //一致していない
207          return 0;
208      }
209  }
210
211  int operator==(char* string, MCString& s ) {
212      if ( !strcmp( string, s.m_String ) ) {
213          //一致
214          return 1;
215      } else {
216          return 0;
217      }
218  }
219
220  int MCString::operator !=(char *string)
221  {
222      if ( !strcmp( this->m_String, string )) {
223          //一致している
224          return 0;
225      }  else {
226          //一致していない
227          return 1;
228      }
229  }
230
231  int MCString::operator !=( MCString& s ) {
232      if ( !strcmp( this->m_String, s.m_String ) ) {
233          //一致している
234          return 0;
235      } else {
236          //一致していない
237          return 1;
238      }
239  }
240
241  int operator!=(char* string, MCString& s ) {
242      if ( !strcmp( string, s.m_String ) ) {
243          //一致している
244          return 0;
245      } else {
246          //一致していない
247          return 1;
248      }
249  }
250