Variable Inheritence

[Lil'Hasher]

Hi
I have an issue with variables in parent and child classes.
Basically what I want to do is create a method in the parent class that is used within all the child classes. However the method uses a variable 'n' that I want to be different for each child class.

How would I go about doing this? I cant seem to get it to work.
Is there a way to override variables maybe?

Thanks

[PaulWendt]

Is the type of n changing? Is the function's contents static, but
you want only the type to change? If so, you could use a member
template function. You can't virtual-ize these, though, so you'd
need another approach if the functions need to be overridden
in the derived classes.

--Paul

[Graham]

If your base class function consists of mostly common code, with only a small amount differing in the derived classes you could try the Template Pattern:

class base
{
public:
    void some_function()
    {
        // do some common processing...
        variable_part();
        // more processing...
    }
protected:
    virtual void variable_part() {}
};

class derived: public base
{
    // ...
protected:
    void variable_part()
    {
        // processing specific to this class
    }
};

of course, this can be simplified if the variable is of the same type in all classes by adding a virtual function to get the value. In this case, I would make the function in the base class pure and private:

class base
{
    // .....

private:
    virtual int get_n() = 0;
};

[dude_1967]

Lil'Hasher,

Please specify more clearly the use of n. Is n a member of the parent base-class? As Paul asked, when you say that you want n to be different for each child-class, is the type of n changing or do you mean that each child class has it's own unique instance of n?

Paul, I get the feeling that the question might be simpler to handle than the ideas in your post.

Sincerely,
Chris.

[Lil'Hasher]

Hi Guys,

Well my actual problem is that I would like to have a string variable for each derived class, each with a different length.
However there is a method that is common to all the classes and uses this string.

So for example

class base{
public:
char name[20];

base(char* str){
strcpy(name, str);
}

//Other methods that use name
}

class derived: public base{
public:
char name[3];
};

I need something like that, although I dont think the above code works the way I would like it to. I've tried using "this" and other tricks but nothing seems to work. I understand Graham's suggestion....but is that the simplest way to do this??

thanks again

[Paul McKenzie]

I would like to have a string variable for each derived class, each with a different length

Use std::string in the base class. This solves your problem:

#include <string>
#include <iostream>

class foo {
//...
     protected:
          std::string thisString;

     public:
          void SetString(const std::string& s) 
          {
                thisString = s;
          }

          void PrintLength() { std::cout << "Length of string is " << thisString.length() << std::endl; }
};

class fooDerived : public foo
{
};

class fooDerived2 : public foo
{
};

int main()
{
    fooDerived s;
    fooDerived s2;
    s.SetString("ABCDEF");
    s2.SetString("123");
    s.PrintLength();
    s2.PrintLength();
    return 0;
}

For s, the length of the string is 6, for s2, the length is 3.

Regards,

Paul McKenzie

[Lil'Hasher]

is there anyway at all to do this using a character array? I was so sure it was possible and that I was just forgetting something.

Thanks for all the help, I appreciate it

Lil'Hash

[PaulWendt]

For a char array whose size is dynamic, you'll need a char* and
that char* will point to dynamically allocated data.

class Base
{
public:
   Base() : m_pString(0) {}
   ~Base() { if m_pString { delete [] m_pString; }

   void setString(const char* input)
   {
      m_pString = new char[strlen(input) + 1];
      strcpy(m_pString, input);
   }

private:
   char* m_pString;
};

However, I strongly recommend that you use std::string because
of all of the memory allocation you'll have to worry about with
the approach I outlined above.

--Paul

[Paul McKenzie]

Originally posted by Lil'Hasher
is there anyway at all to do this using a character array? I was so sure it was possible and that I was just forgetting something.

Thanks for all the help, I appreciate it

Lil'Hash

As Paul W. pointed out, you have to manage the memory yourself. One thing Paul left out of his example is that you need to write a copy constructor and assignment operator to properly manage your class if you use char *. I will post them and you can tell me which one you feel is easier to maintain.

First, char *

class Base
{
public:
   Base() : m_pString(0) {}
   ~Base() { if m_pString { delete [] m_pString; }

   void setString(const char* input)
   {
      delete [] m_pString;
      m_pString = new char[strlen(input) + 1];
      strcpy(m_pString, input);
   }

   Base(const Base& rhs)
   {
         setString( rhs.m_pString );
   }
 
   Base& operator = (const Base& rhs)
   {
        if ( this == &rhs )
           return *this;
       setString( rhs.m_pString )
       return *this;
   }

private:
   char* m_pString;
};

Second std::string

class Base
{
public:
   void setString(const std::string& input)
   {
      m_String = input;
   }

private:
   std::string m_String;
};

Now which one is more preferable and easier to maintain and understand? If you don't understand the copy constructor and assignment operator, that is more reason to use std::string.

Again, use what's there -- std::string. It works, it is standard, doesn't need any code to manage memory, and the proper C++ way to accomplish what you are seeking. Unless there is a compelling (and really compelling) reason to use a char array, you should use std::string.

Regards,

Paul McKenzie