Source: Internet
Author: User

The way the member function is overloaded, the prototype is:

Function type & operator ++ ();

The friend function is overloaded. The prototype is:

friend function type & operator ++ (class type &);

The member function is overloaded. The prototype is:

Function type operator ++ (int);

The friend function is overloaded. The prototype is:

friend function type operator ++ (class type &, int);

The member function is overloaded. The prototype is:

Function type & operator-();

The friend function is overloaded. The prototype is:

friend function type & operator-(class type &);

The member function is overloaded. The prototype is:

Function type operator-(int);

The friend function is overloaded. The prototype is:

friend function type operator-(class type &, int);

#include <iostream>
using namespace std;

class Integer
{
public:
Integer (int n);
~ Integer ();

Integer & operator ++ ();
// friend Integer & operator ++ (Integer & i);
Integer operator ++ (int n);
// friend Integer operator ++ (Integer & i, int n);

Integer & operator-();
// friend Integer & operator-(Integer & i);
Integer operator-(int n);
// friend Integer operator-(Integer & i, int n);
void Display () const;
private:
int n_;
};

Integer :: Integer (int n): n_ (n) {}

Integer :: ~ Integer () {}

Integer & Integer :: operator ++ ()
{
++ n_;
return * this;
}

// Integer & operator ++ (Integer & i)
// {
// ++ i.n_;
// return i;
//}

Integer Integer :: operator ++ (int n)
{
// n _ ++;
Integer tmp (n_);
n _ ++;
return tmp;
}

// Integer operator ++ (Integer & i, int n)
// {
// Integer tmp (i.n_);
// i.n _ ++;
// return tmp;
//}

Integer & Integer :: operator-()
{
--n_;
return * this;
}

// Integer & operator-(Integer & i)
// {
// --i.n_;
// return i;
//}

Integer Integer :: operator-(int n)
{
// n _--;
Integer tmp (n_);
n _--;
return tmp;
}

// Integer operator-(Integer & i, int n)
// {
// Integer tmp (i.n_);
// i.n _--;
// return tmp;
//}

void Integer :: Display () const
{
cout << n_ << endl;
}

int main (void)
{
Integer n (100);
n.Display ();

cout << "++ stage" << endl;
Integer n2 = ++ n;
n.Display ();
n2.Display ();

Integer n3 = n ++;
n.Display ();
n3.Display ();

cout << "--stage" << endl;
Integer m (100);
Integer m2 = --m;
m.Display ();
m2.Display ();

Integer m3 = m--;
m.Display ();
m3.Display ();
return 0;
}
operation result:
100
++ stage
101
101
102
101
--stage
99
99
98
99

It should be noted that in order to distinguish it from the front ++, the rear ++ has an int parameter, but it has no effect. When you set a breakpoint to debug, you can find that the default assignment is 0. And member functions cannot coexist with friend functions at this time, because the ++ operator is not clear.

#include <iostream>
#include <string>
#include <string.h>
using namespace std;

class CMyString
{
public:
CMyString (const char * pData = NULL);
CMyString (const CMyString & other);
~ CMyString ();
CMyString & operator = (const CMyString & str);
bool operator! () const;

void display () const;
private:
char * m_pData;
};

CMyString :: CMyString (const char * pData)
{
if (pData == NULL)
{
m_pData = new char [1];
* m_pData = '\ 0';
}
else
{
int length = strlen (pData);
m_pData = new char [length + 1];
strcpy (m_pData, pData);
}
}

CMyString :: CMyString (const CMyString & other)
{
int Len = strlen (other.m_pData);
m_pData = new char [Len + 1];
strcpy (m_pData, other.m_pData);
}

CMyString :: ~ CMyString ()
{
delete [] m_pData;
}

CMyString & CMyString :: operator = (const CMyString & str)
{
if (this == & str)
return * this;
delete [] m_pData;
m_pData = NULL;
m_pData = new char [strlen (str.m_pData) + 1];
strcpy (m_pData, str.m_pData);
return * this;
}

bool CMyString :: operator! () const
{
return strlen (m_pData)! = 0;
}

void CMyString :: display () const
{
cout << m_pData << endl;
}

int main ()
{
CMyString s1 ("abc");
CMyString s2;
s2 = s1;
s2.display ();

s2 = "def";
s2.display ();

CMyString s3;
bool noempty;
noempty =! s3;
cout << noempty << endl;

s3 = "abc";
noempty =! s3;
cout << noempty << endl;
return 0;
}
operation result:
abc
def
0
1
Explanation: Suppose there are three objects, str1, str2, str3. In the program, the statement str1 = str2 = str3 will fail to compile. The! Operator here means true when the string is not empty.

In the following code, operator + calls the implementation of operator + =; the stream operator can only be overloaded as a friend function, because the first parameter is a stream reference, not a String class.

#include <iostream>
#include <string>
#include <string.h>
using namespace std;

class String
{
public:
String (const char * str = "");
String (const String & other);
String & operator = (const String & other);
String & operator = (const char * str);

bool operator! () const;
char & operator [] (unsigned int index);
const char & operator [] (unsigned int index) const;

friend String operator + (const String & s1, const String & s2);
String & operator + = (const String & other);

friend ostream & operator << (ostream & os, const String & str);
friend istream & operator >> (istream & is, String & str);
~ String (void);

void Display () const;
int Length () const;
bool IsEmpty () const;

private:
String & Assign (const char * str);
char * AllocAndCpy (const char * str);
char * str_;
};

String :: String (const char * str)
{
str_ = AllocAndCpy (str);
}

String :: String (const String & other)
{
str_ = AllocAndCpy (other.str_);
}

String & String :: operator = (const String & other)
{
if (this == & other)
return * this;

return Assign (other.str_);
}

String & String :: operator = (const char * str)
{
return Assign (str);
}

String & String :: Assign (const char * str)
{
delete [] str_;
str_ = AllocAndCpy (str);
return * this;
}

bool String :: operator! () const
{
return strlen (str_)! = 0;
}

char & String :: operator [] (unsigned int index)
{
return const_cast <char &> (static_cast <const String &> (* this) [index]);
}

const char & String :: operator [] (unsigned int index) const
{
return str_ [index];
}

String :: ~ String ()
{
delete [] str_;
}

char * String :: AllocAndCpy (const char * str)
{
int len = strlen (str) + 1;
char * newstr = new char [len];
memset (newstr, 0, len);
strcpy (newstr, str);

return newstr;
}

void String :: Display () const
{
cout << str_ << endl;
}

int String :: Length () const
{
return strlen (str_);
}

bool String :: IsEmpty () const
{
return Length () == 0;
}

String operator + (const String & s1, const String & s2)
{
String str = s1;
str + = s2;
return str;
}

String & String :: operator + = (const String & other)
{
int len = strlen (str_) + strlen (other.str_) + 1;
char * newstr = new char [len];
memset (newstr, 0, len);
strcpy (newstr, str_);
strcat (newstr, other.str_);

delete [] str_;

str_ = newstr;
return * this;
}

ostream & operator << (ostream & os, const String & str)
{
os << str.str_;
return os;
}

istream & operator >> (istream & is, String & str)
{
char tmp [1024];
cin >> tmp;
str = tmp;
return is;
}

int main (void)
{
String s1 ("abcdefg");

char ch = s1 [2];
cout << ch << endl;

s1 [2] = 'A';
s1.Display ();

const String s2 ("xyzabc");
ch = s2 [2];
s2.Display ();

String s3 = "xxx";
String s4 = "yyy";

String s5 = s3 + s4;
s5.Display ();

String s6 = "aaa" + s3 + "sdfadfa" + "xxxx";
s6.Display ();

s3 + = s4;
s3.Display ();

cout << s3 << endl;

String s7;
cin >> s7;
cout << s7 << endl;

if (! s7.IsEmpty ())
cout << s7.Length () << endl;

return 0;
}
operation result:
c
xyzabc
xxxyyy
xxxyyy
xxxyyy
asdfasdf
asdfasdf
8

reference:

C ++ primer fourth edition

Related Keywords:
Related Article

The content source of this page is from Internet, which doesn't represent Alibaba Cloud's opinion; products and services mentioned on that page don't have any relationship with Alibaba Cloud. If the content of the page makes you feel confusing, please write us an email, we will handle the problem within 5 days after receiving your email.

If you find any instances of plagiarism from the community, please send an email to: info-contact@alibabacloud.com and provide relevant evidence. A staff member will contact you within 5 working days.

## A Free Trial That Lets You Build Big!

Start building with 50+ products and up to 12 months usage for Elastic Compute Service

• #### Sales Support

1 on 1 presale consultation

• #### After-Sales Support

24/7 Technical Support 6 Free Tickets per Quarter Faster Response

• Alibaba Cloud offers highly flexible support services tailored to meet your exact needs.