Classes

Hey Im having a problem with passing arguments into a function from a class.This is my program with just prototypes and function calls. I am confused when to pass by pointer and by reference.

Header file

Code:

#ifndef STRING_HPP
#define STRING_HPP

#include <iostream>

using namespace std;
class mystring
{
    typedef struct STRING* String;

    struct STRING
    {
        int size;
        char *theString;
    };



private:
void validateString( mystring &theString );

public:
mystring()
{
	String->theString = NULL;
	String.size =0;
}
mystring( char *init)
{
	newString( init );
}

~mystring()
{
	destroyString( theString );
}
mystring&  destroyString( mystring &theString );
mystring& newString( char* theString );
void printString(mystring &theString);
char charAt( mystring &theString, int index );
mystring& operator+( mystring &string1, mystring &string2 );
};



#endif

Function definitions

Code:

#include <iostream.h>

#include <assert.h>
#include "mystring.hpp"
using namespace std;

int stringCount = 0;

mystring& mystring::newString( char& init )
{
  /*Function definition */

  return( newString );
}

 void mystring::validateString( mystring &theString )
{
   /*Function definition */
}

mystring& mystring::destroyString( mystring &theString )
{
   /*Function definition */

  return( theString );
}

void mystring::printString( mystring &theString )
{
  validateString( theString );

  cout << theString->size << theString -> theString << endl );
}

char* mystring::charAt( mystring &theString, int index )
{
  validateString( theString );
  assert( index >= 0 );
  assert( index < theString -> size );

  return( theString -> theString[index] );
}

mystring& mystring::operator+( mystring &string1, mystring &string2 )
{
   /*Function definition */
  return( newString );
}

Especially when I am overloading the operator + for the purpose of concatenation, I get an error stating that 0 or 1 argument only has to be passed. Please help.

Your operator+ when it is member of a class will only take one argument (the right-hand side part), because the left-hand side is defined by the current object (this) in your.

So if you do:
x = y + z;
then it's the same as x = y.operator+(z).

You can do your operators as free functions instead, which would allow you to have to arguments.

--
Mats

If your operator + is a member function (which it is, since it is mystring:perator +), then the first argument is always "this" -- hence + should only take one (other) argument. In other words, choose one:

Code:

mystring& mystring::operator+(const mystring &string2);
mystring& operator+(const mystring &string1, const mystring &string2);

There's no need to pass anything by pointers that I can see. And you'll want to put const everywhere you don't expect that argument to change.

What is free functions?
As I am not using the string class, I have to define a function with operator overloading. My function definitions such as mystring& operator+(const mystring &string1, const mystring &string2), is in a another file which is different from my class file.
So when im calling the function isnt it supposed to be z = x + y;?

I think I got what your saying, thanks to tabstop.

Also, my 1st constructor is giving problems.

Originally Posted by Ron

I think I got what your saying, thanks to tabstop.

Also, my 1st constructor is giving problems.

String->size = 0. (Look at the line above!)

hmmm.. so another question, in the operator + when Im working with the 'this'. would the syntax be this.theString or this->theString?

im still getting the same error in the constructor for both theString and size
error:expected primary-expression before '->' token

It seems to me that the first problem is that your class does not have any member variables. If I am reading it correctly, all you have done is define a private POD struct as an inner class of your mystring class. What you probably want to do is just declare two member variables:

Code:

class mystring
{
public:
    // ...
private:
    int size;
    char* theString;
};

By the way, do not use using directives in header files except within a local scope.

"this" is a pointer, so treat it as such.