Thread: my short sightedness........ help....

my first question why is the function parameter "const CmyString& b" and not just "const CmyString b"

When the argument you send to the function is CmyString (vs. CmyString&), a copy of the object is made for the function. The function then operates on the copy, and any changes it makes to the copy are not reflected in the original object that was sent to the function. When the function ends, the copy of the object is destroyed.

When the argument you send to the function is CmyString&, then only the address of where the object is in memory is sent to the function. Once again, a copy of the argument is made for the function, but this time what is being copied for the function is an address. However, an address and a copy of an address both refer to the same object. Therefore, when you make changes to the object inside the function using a copy of an address, the changes are made directly to the original object.

The bottom line is that making changes to an object whether it's through an address or a copy of an address both yield the same result: the original(and only object in existence) is changed. On the other hand, when an object is copied for a function, two objects exist: the original and the copy, and the function operates on the copy, which means the original object is unaffected.

So, using that little & symbol has two effects:

1) It's more efficient. It causes only the object's address in memory to be copied for the function. Copying just an object's address, which you can think of as an integer, is much quicker than copying the whole object, which may have many members.

2) It allows you to change the original object. When the function makes changes to the object, the changes are made directly to the original object that was sent to the function.

In your case, you have additionally declared the function parameter "const", which prevents the function from changing the object, nullifying effect (2). That is a good practice when your function doesn't need to change the object. As a result, you get only one of the effects of using the "&" symbol: efficiency.

but the object returned by a.operator+(b) will be destroyed... or will it not be ..... ?????

[deleted because it was incorrect]

the return type "CmyString&" makes sure that we can execute statements like

The question is whether you need to return anything from operator=(). If you write this:

a = b;

operator=() doesn't need to return anything. It can just set the values of a equal to the values of b. However, if you want to be able to write statements like this for your class:

a = b = c;

then your operator=() has to return something. A statement like that is executed from right to left, like this:

a = (b = c);

If your operator=() doesn't return anything, then you will get:

a = (void);

which is not what you want. The reason you make the return value of operator=() a reference is for efficiency. When you return a reference, the whole object doesn't have to be copied--only its address in memory is copied and returned.

All the operator overload functions follow specific formats. You can look up any of them and get the proper format. As for operator+(), you will want to write statements like this:

a = b + c;

So, operator+() needs to return a new object that results from (b + c). You could just add c to b and return b, but then b would be altered. The normal operation is to leave b and c unchanged. Since you are going to be creating a new object in your operator+() function, you do not want to return a reference to that object. When a function ends, the variable names declared inside it are destroyed. So, if you return a reference to the object, it will refer to something that doesn't exist.

As a result, you want to pass by value in your return statement. That way, a copy of the object you declared in your operator+() function will be returned. The original will get destroyed when the function ends, but that won't affect the copy. You pass by value in your return statement by omitting the & symbol.

Here are the files you will need, the name of the file is commented on top:

Code:

// myString.h: interface for the CmyString class.
//
//////////////////////////////////////////////////////////////////////

#if !defined(AFX_MYSTRING_H__60C5F526_B091_4FE3_B074_23E7BF46A940__INCLUDED_)
#define AFX_MYSTRING_H__60C5F526_B091_4FE3_B074_23E7BF46A940__INCLUDED_

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

class CmyString  
{
public:
	CmyString& operator+=(const CmyString& b);
	CmyString operator+(const CmyString& b);
	CmyString& operator=(const CmyString& b);
	CmyString(char* pstr ="Default String");
	CmyString(const CmyString& temp);
	virtual ~CmyString();
	void printstr();
	char* getString() const { return m_pstr; };



private:
	int length;
	char* m_pstr;
};

#endif // !defined(AFX_MYSTRING_H__60C5F526_B091_4FE3_B074_23E7BF46A940__INCLUDED_)

Code:

// myString.cpp: implementation of the CmyString class.
//
//////////////////////////////////////////////////////////////////////

#include "myString.h"
#include <iostream>
#include <cstring>
using namespace std;

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CmyString::CmyString(char* pstr)
{
	m_pstr = new char [strlen(pstr) + 1];
	strcpy(m_pstr, pstr);
	length = strlen(m_pstr);
}

CmyString::CmyString(const CmyString& temp)
{
	m_pstr = new char [strlen(temp.m_pstr) + 1];
	strcpy(m_pstr, temp.m_pstr);
}

CmyString::~CmyString()
{
	delete [] m_pstr;
	m_pstr = NULL;
}

void CmyString::printstr()
{
	cout << m_pstr << endl;
}


CmyString& CmyString::operator=(const CmyString& b)
{
	if(this != &b)
	{
		length= b.length;
		delete [] m_pstr;
		m_pstr = new char[strlen(b.m_pstr) + 1];
		strcpy(m_pstr, b.m_pstr);
	}

	return *this;
}

CmyString CmyString::operator+(const CmyString& b)
{
	CmyString temp;
	temp.length = this->length + b.length;
	delete [] temp.m_pstr;
	temp.m_pstr = new char [temp.length + 1];
	strcpy(temp.m_pstr, this->m_pstr);
	strcat(temp.m_pstr, b.m_pstr);
	
	return temp;
}

CmyString& CmyString::operator+=(const CmyString& b)
{
	this->length += b.length;
	char* tempString = new char [this->length + 1];
	strcpy(tempString, this->m_pstr);
	delete[] this->m_pstr;
	this->m_pstr = new char [this->length + 1];
	strcpy(this->m_pstr, tempString);
	strcat(this->m_pstr, b.m_pstr);
	
	return *this;
}

Code:

// string_main.CPP
// A sample string problem
#include <iostream>
#include "myString.h"
using namespace std;

int main()
{
	CmyString a ("my first");
	CmyString b ("your first");
	CmyString c ("our first");
	a.printstr();
	b.printstr();
	c.printstr();
	CmyString d;
	d = a+b+c;
	d.printstr();
	//c += a;
	//c.printstr();

   return 0;
}