minor encapsulation issue

[Trazlo Trevize]

Heya, I have a little issue.

#include	<string>
//	class taggable
//	lets me tag an instance of a class with a name that means something to me.
class	taggable
{public	:	//	nonconst methods
	bool	set_tag( const std::string& new_tag )
	{	this->tag = new_tag	;
		return	true	;
	}
//private	:	//	internal data	//	this is commented out because I would prefer to use the private here, but am using public so the example will compile.
public	:
	std::string	tag	;
}	;

//	class	kiddy
//	an example class that is a taggable
class	kiddy	:	public taggable
{
}	;

//	class	grade
//	an example class that is a taggable
class	grade	:	public taggable
{
}	;

//	class something
//	an example class that has a kiddy and has a grade in addition to being a taggable.
class	something	:	public taggable
{public	:	//	nonconst methods
	//	set_tag
	bool	set_tag( const std::string& new_tag )
	{	this->tag = new_tag	;	//	this does not encapsulate the functionality of class taggable. Or at least I think "encapsulate" is the right term to talk about here, right?
		this->something_useful.set_tag( new_tag+"'s kiddy" )	;
		this->something_nifty.set_tag( new_tag+"'s grade" )	;
		return	true	;
	}
private	:	//	internal data
	kiddy	something_useful	;
	grade	something_nifty	;
}	;

Here we have class taggable that I'm wanting to have many of my classes inherit from so I can have its functionality in all of them, namely the ability to name each of them so I can keep track of who is who and so on.

My issue is that I want to be able to change the functionality of the set_tag function based on the class its in, but I don't have any particular desire to know how the taggable class is implemented. I've run into the specific scenario where when an object that is taggable "has an" object that is also taggable, I would like to be able to write a new set_tag function for that object that will change the name of that object and its possessions.

Unfortunately, I don't think making set_tag virtual in class taggable and writing a new set_tag for any dervied object with strange needs is what I want since I explicitly don't want to have to know how class taggable actually goes about setting its own tags.

What would solve this problem I think would be a way to explicitly call the set_tag function in taggable from the set_tag function in class something, but I don't know how to do this. Does anyone have any ideas?

[HighCommander4]

You can call the base class version of a function (taggable::set_tag) from the derived class version (something::set_tag) by qualifying it with the base class name explicitly:

#include <string>

// class taggable
// lets me tag an instance of a class with a name that means something to me.
class taggable
{
public:	//	nonconst methods
	bool set_tag(const std::string& new_tag)
	{	
        this->tag = new_tag;
		return true;
	}
private	:	//	internal data	// NOW COMPILES FINE
std::string	tag	;
};

// class	kiddy
// an example class that is a taggable
class kiddy	: public taggable
{
};

// class	grade
// an example class that is a taggable
class grade	: public taggable
{
};

// class something
// an example class that has a kiddy and has a grade in addition to being a taggable.
class something	: public taggable
{
public:	//	nonconst methods
	//	set_tag
	bool set_tag(const std::string& new_tag)
	{	
        taggable::set_tag(new_tag);  // CALL BASE CLASS VERSION
        this->something_useful.set_tag( new_tag+"'s kiddy" )	;
		this->something_nifty.set_tag( new_tag+"'s grade" )	;
		return	true	;
	}
private	:	//	internal data
	kiddy something_useful	;
	grade something_nifty	;
};

[Trazlo Trevize]

That's nifty & works, thanks!