OSDev.org

Code: Select all

Modified:--
class string
{
   private:
      char* str;

   public:
   string()
   {
      str=new char[1];
      str[0]='\0';
   }
   string(const char* s)
   {
      int len=strlen(s);
      str=new char[len+1];
      strcpy(str,s);
   }
   int length()
   {
      return(strlen(str));
   }
   void input()
   {
      char t[100];
      cin>>t;
      int len=strlen(t)+1;
      str=new char[len];
      strcpy(str,t);
   }
   const char* text()
   {
      return(str);
   }
   string operator + (string s2)
   {

      string t;
      int tlen=this->length()+s2.length()+1;
      t.str=new char[tlen];
      strcpy(t.str,this->str);
      strcat(t.str,s2.str);

      return(t);
   }
};

Code: Select all

#include"iostream.h"
#include"string.h"
#include"conio.h"

class string
{
   private:
      char* str;

   public:
   string()
   {
      str=new char[1];

      // Memory leak. You're making str point to a
      // different string without freeing the one
      // you just allocated.
      str="";
   }

   // The parameter should be const char*, since you
   // do not need to modify the string pointed to by s.
   string(char* s)
   {
      int length=strlen(s);
      str=new char[length+1];
      strcpy(str,s);
   }
   string(int m)
   {
      // This leaves the memory pointed to by str
      // uninitialized. This is a big problem if
      // someone calls text expecting the result
      // to be a null-terminated C-style string.
      str=new char[m+1];
   }
   int length()
   {
      // This will break horribly if str is not
      // null terminated -- see the constructor
      // above.
      return(strlen(str));
   }
   void input()
   {
      // I don't think this does what you intend
      // it to do. I can't test it ATM, but to
      // me it looks like it's waiting for the
      // user to type in an address to put in
      // str.
      cin>>str;
   }
   char* text()
   {
      // str MUST be null-terminated or this
      // becomes a really bad idea.
      return(str);
   }

   // I would probably make this a friend
   // function that takes two string parameters
   // instead of making it a member function.
   // This is more of a style thing though.
   // Also, s2 should be a const string& for
   // the sake of efficiency.
   string operator + (string s2)
   {

      char* t;
      t=new char[length()+1];
      string tmp;
      tmp.str=new char[ length() + s2.length() + 1];
      strcpy(t,this->str);

      // The strcat here is going to break something,
      // since you didn't allocate enough space to
      // hold the contents of both s1 and s2. I
      // think you meant to strcat directly into
      // tmp.str. If you think about it, there's
      // no need for t at all here.
      strcpy(tmp.str,strcat(t,s2.str));
      delete t;
      return(tmp);
   }
   ~string()
   {
      // You allocated with array new, so you must
      // delete with array delete: delete [] str
      delete str;
   }
};
void main()
{
   string a="hello";
   string b=" world";
   string c;
            c=a+b;
   cout<<c.text()<<endl;
   
   getch();
}

Code: Select all

int main()
{
    string a = "foo";
    string b = a;
    return 0;
}

Code: Select all

string a;
a="Foo";

Code: Select all

class string
{
...
public:

    string( const string& other )
    {
        str = new char[other.length() + 1];
        strcpy( str, other.str );
    }

    string& operator=( const string& other )
    {
        if (&other != this)
        {
            // Copy the contents of the other string into
            // a temporary object. If something goes wrong,
            // at least the contents of this object remain
            // intact.
            string tmpString( other );

            // Swap the fields of this object for those in the
            // temporary copy. This is efficient, exception-safe,
            // and tidy since it ensures that the old contents
            // of this object will be freed by tmpString's
            // destructor when tmpString goes out of scope.
            swap( tmpString );            
        }
        return *this;
    }

private:

    void swap( string& other )
    {
        char* tmpStr = str;
        str = other.str;
        other.str = tmpStr;
    }
...
};

Code: Select all

string operator + (string s2)
  {

      string t;
      int tlen=this->length()+s2.length()+1;
      t.str=new char[tlen];
      strcpy(t.str,this->str);
      strcat(t.str,s2.str);

      return(t);
  }

~string()
{
       delete str;
}

Code: Select all

    ~string()
    {
        delete [] str;
    }

Code: Select all

// this assumes your current class design
// note that in a copy constructor, the
// argument *must* be a ref variable

string::string(string& src)
{
    if (NULL == src.str)
    {
        str = NULL;
    }
    else 
    {
        int len = src.length() + 1;
        str = new str[len];
        strncpy(str, src.str, len);
    }
}

Code: Select all

string::string(string& src)
{
 

Code: Select all

void input()
   {
      char t[100];
      cin>>t;
      int len=strlen(t)+1;
      str=new char[len];
      strcpy(str,t);
   }

Code: Select all

void string::pwinput(char symbol)//symbol is the char i.e echoed.
   {
      char a[7];
      int enter=13;

      int k=0,i=0;
       while(k!=enter && i!=7)
       {
      if(i!=7)
         k=getch();

      if(valid(k) && k!=enter)
      {
         a[i]=k;
         cout<<symbol;
         i++;
      }
        }
        int len=i;
        str=new char[len+1];
        for(i=0;i<len;i++)
        {
      str[i]=a[i];
        }
        str[i]='\0';
    }

private:

int valid(char n)//CHECKS IF n IS A LETTER OR NUMBER
{
 int in=n;
 if ( (in>=97 && in<=122) || (in>=65 && in>=90) || (in>=48 && in<=57) )
   return 1;
 else
   return 0;
}