EX3 Code Review. Instructor: Tsung-Che Chiang

Transcription

1 EX3 Code Review Instructor: Tsung-Che Chiang Department of Computer Science and Information Engineering National Taiwan Normal University The Practice of Programming, Fall, 2010

2 Exercise Write a classstring to simulatestd::string. class String public: // 1. default constructor // 2. copy constructor // 3. constructor with one parameter with type const char * // 4. destructor // 5. size() // 6. c_str() // 7. copy assignment // 8. operator [] // 9. operator += private: char *str_; ; // A. operator < // B. operator << 2

3 String(const char *) String::String(const char *from) ptr = (char*) malloc(strlen(from)+1); strcpy(ptr, from); ptr[strlen(from)] = '\0'; redundant String::String(const char* s) str_ = new char[ strlen(s + 1) ]; for( int i=0; i<strlen(s); i++ ) str_[i] = s[i]; str_[strlen(s)] = '\0'; wrong size

4 String(const char *) String::String(const char *ptr) int length = 0; while(ptr[length]!= '\0') length++; length++; str_ = new char[length]; for(int i = 0; i < length;i++) str_[i] = ptr[i]; Use library to save your time.

5 String & operator = (const String &) String & operator = ( const String &assign ) str_ = new char[strlen(assign.str_)+1]; strcpy( str_, assign.str_ ); memory leak return? String & String:: operator =(const String &rhs ) if( this == &rhs ) return *this ; delete str_; use delete [] this-> str_ = rhs.str_; return *this ; double pointers to same location

6 String & operator = (const String &) String & String::operator = (const String &rhs) if(this == &rhs) return *this; delete [] this->str_; int rhs_length = rhs.size(); this->str_ = new char[rhs_length+1]; //strcpy(this->str_, rhs.c_str()); memcpy(this->str_, rhs.c_str(), rhs_length+1); delete too early why memcpy for strcpy? return *this;

7 String & operator = (const String &) String String::operator=(const char * input) size_t newsize=strlen(input); if(size_!=newsize) delete [] str; size_=newsize; str=new char[size_+1]; strcpy(str,input); return *this; delete too early Copy-and-swap is still applicable. String& String::operator= (const String &rhs) strcpy(str, rhs.str); return *this; enough space?

8 String & operator += (const String &) String & operator += (const String & tail) char *temp = (char *)malloc(sizeof(char)*strlen(str_)+1); strcpy(temp, str_); free(str_); redundant str_=(char*)malloc(sizeof(char)*strlen(temp)+ sizeof(char)*strlen(tail.str_)+1); strcpy(str_, temp); strcat(str_, tail.str_); free(temp); return *this; ; String & String::operator += ( const String &tail) String temp( str_); str_ = new char [strlen(str_)+strlen(tail.str_)+1]; strcpy( str_, temp.str_); strcat( str_, tail.str_); memory leak return? 8

9 String & operator += (const String &) String & String::operator += (const String &tail) char *temp = new char[strlen(str_) + 1]; strcpy (temp, str_); delete []str_; redundant str_ = new char[strlen(temp) + strlen(tail.str_) + 1]; strcpy (str_, temp); strcat (str_, tail.str_); delete []temp; return *this; String & operator += ( const String &tail ) strcat( str_, tail.str_ ); enough space? return?

10 String & operator += (const String &) String & operator +=(const String &tail) char * temp=new char[strlen(str_)+1]; temp=str_; str_=new char[strlen(str_)+strlen(tail.str_)+1]; strcat(strcpy(str_,temp),tail.str_); delete temp; delete [] String & operator +=(const String &tail) int totallen=strlen(str_)+strlen(tail.str_); char *newstr; newstr =new char[totallen + 1]; memset(newstr,'\0',totallen + 1); strcat(newstr,(*this).str_); strcat(newstr,tail.str_); str_=newstr; return (*this); memory leak return? initialization memory leak

11 String & operator += (const String &) String &String::operator += (const String &tail) char * str = new char[ strlen(tail.str_) + strlen( str_ ) + 1 ]; strcpy( str, str_ ); strcat( str, tail.str_ ); str[ strlen(tail.str_) + strlen( str_ ) ] = '\0'; delete [] str_; str_ = str; return *this; redundant

12 String & operator += (const String &) String& String::operator += (const String &from) char *ans = (char*) malloc( this->size() + from.size() + 1 ); ans = strcpy(ans, ptr); ans = strcat(ans, from.ptr); String anst(ans); free(ans); String::swap(&anst, this); redundant return *this;

13 String & operator += (const String &) char & String::operator+=( const String & tial) size_=size_+tial.size(); char* temp=new char[size_+1]; temp[0]='\0'; strcat(temp,str); strcat(temp,tial.c_str()); delete[] str; str=temp; return *str;

14 bool operator < (const String &, const String &) bool operator < (const String & lhs, const String &rhs) //strcmp if(strcmp(lhs.c_str(), rhs.c_str())==-1) return true; else return false; not following the standard bool operator < ( const String &lhs, const String &rhs) if( strcmp( lhs.c_str(), rhs.c_str()) < 0) return true; else return false; redundant

15 bool operator < (const String &, const String &) bool operator < (const String &lhs, const String &rhs) for(int i=0;i<lhs.size()&&i<rhs.size();i++) if(lhs[i]==rhs[i]) continue; if(lhs[i] < rhs[i]) return true; else return false; if(lhs.size() < rhs.size()) return true; else return false; Library is better than your handmade codes.

16 bool operator < (const String &, const String &) bool operator < (const String &a, const String &b) int al = a.size(); What if a and b are the same? for(int i = 0; i <= al; i++) if(a[i] < b[i]) return true; if(a[i] > b[i]) return false; Library is better than your handmade codes. bool operator< ( const String & lhs, const String & rhs) if(strcmp(lhs.c_str(),rhs.c_str())<0) return true; Else?

17 bool operator < (const String &, const String &) bool operator < (const String &lhs, const String &rhs) return ((strcmp (lhs.c_str(), rhs.c_str()) < 0)? true : false); redundant bool operator < (const String& lhs, const String& rhs) return strcmp(lhs.c_str(), rhs.c_str()) == -1; bool operator < (const String &left, const String &right) return(left.size() < right.size()); non-standard unusual

18 Misc istream &operator>>( istream & input, String &data) char temp[100]; input >> temp; data=temp; return input; char String::operator [] (int index) const if (index < strlen(str_)) return str_[index]; Else?

19 Misc Const-ness int size() return strlen( str_); char *c_str()const return str_; Incomplete implementation void String::swap(String & input) char * tempptr=str; str = input.str; input.str=tempptr; size_t tempsize=size_; size_=input.size_;

20 Organization bool operator <(const String &lhs,const String &rhs) return strcmp ( lhs.c_str(), rhs.c_str() )<0; ostream& operator <<(ostream &output, const String &rhs) output <<rhs.c_str()<<endl; return output; Do not put non-inline functions in.h. Remember to add #include guard.

21 Exercise #ifndef NTNU_MYSTRING #define NTNU_MYSTRING MyString.h #include <iosfwd> class String public: String(); String(const String &rhs); String & operator= (const String &rhs); String(const char *rhs); ~String(); unsigned int size() const; const char *c_str() const; char operator[] (int index) const; char & operator[] (int index); String & operator += (const String &tail); void swap(string &rhs); private: char *str_; ; bool operator < (const String &lhs, const String &rhs); std::ostream & operator << (std::ostream &os, const String &rhs); #endif

22 Exercise #include "MyString.h" #include <iostream> #include <algorithm> #include <cstring> using std::ostream; MyString.cpp (1/3) String::String() str_ = new char [1]; str_[0] = '\0'; // String::String(const String &rhs) str_ = new char[sizeof(rhs.str_)+1]; strcpy(str_, rhs.str_); // String::String(const char *rhs) str_ = new char[sizeof(rhs)+1]; strcpy(str_, rhs); // String::~String() delete [] str_;

23 Exercise unsigned int String::size() const MyString.cpp (2/3) return strlen(str_); // a lazy and inefficient implementation // const char * String::c_str() const return str_; // void String::swap(String &rhs) std::swap(str_, rhs.str_); // String & String::operator= (const String &rhs) String temp(rhs); swap(temp); return *this; //

24 Exercise char String::operator[] (int index) const return str_[index]; // note. I do not check the boundary. // char & String::operator[] (int index) return str_[index]; // note. I do not check the boundary. // String & String::operator += (const String &tail) char *old = str_; str_ = new char [strlen(str_)+strlen(tail.str_)+1]; strcat(strcpy(str_, old), tail.str_); delete [] old; return *this; // bool operator < (const String &lhs, const String &rhs) return strcmp(lhs.c_str(), rhs.c_str()) < 0; // ostream & operator << (ostream &os, const String &rhs) os << rhs.c_str(); return os; MyString.cpp (3/3)

25 Exercise #include <cstdlib> #include <iostream> #include "MyString.h" main.cpp (1/2) using namespace std; void readonly(const String &s) cout << s[0] << endl; // s[0] = 'b'; // compilation error int main(int argc, char *argv[]) String empty, ntnu("ntnu"), ntnu2(ntnu); cout << empty << ' ' << ntnu << ' ' << ntnu2 << endl; empty = ntnu; // copy assignment cout << empty << endl; // << operator char cstr[] = "aab"; ntnu = "aaa"; ntnu2 = cstr; // conversion + copy assignment // conversion + copy assignment

26 Exercise int main() //... main.cpp (2/2) if (ntnu < ntnu2) // operator < cout << "aaa < aab" << endl; readonly(ntnu); // operator [] const ntnu[0] = 'd'; // operator [] cout << ntnu << endl; (ntnu += ntnu2) += " haha"; // operator += cout << ntnu << endl; system("pause"); return 0;