Thread: Accessing protected class members

Hello,

I have a base class Paths, and a derived class LanguagePaths, which inherits Paths. There are various members of Paths, namely two doubles and a std::list <int>, which I'd like to copy from a Paths object into a LanguagePaths object.

In order to do so, I've overloaded the operator= in LanguagePaths, as follows :

Code:

// LANGUAGE PATHS CLASS
#ifndef _LANGUAGEPATHS_H
#define _LANGUAGEPATHS_H

//#include <list>
#include <set>
#include "paths.h"
#include "shortcuts.h"

class LanguagePaths : public Paths	// INHERITS PATHS
{
	public:
		
		// Constructor
		LanguagePaths();
				
		// Accessors
		bool banned(uint);		// Check if a production is banned
		void insert(uint);		// Insert a ban
		listitr marker();			// Marker position
		listitr setmarker(listitr);	// Set the position of the marker
				
		// Overloaded operator
		LanguagePaths operator= (const Paths &);
		
						
	private:
		
		// Ban list
		set <uint> ban;
		
		// Marker position
		listitr markerpos;
};

#endif

Code:

// SNIPPET OF LANGUAGEPATHS.CPP
// Overloading the equals operator
LanguagePaths LanguagePaths::operator=(const Paths & original)
{
	// Set length and coefficients equal
	length = original.length;
	coefficient = original.coefficient;
	
	// Set path description to be the same
	path = original.path;
}

Code:

// PATHS CLASS
#ifndef _PATHS_H
#define _PATHS_H

#include <list>
#include "edge.h"
#include "vertex.h"
#include "graph.h"
#include "shortcuts.h"
using namespace std;




class Paths
{
	public:
		
		// Constructor
		Paths();
		
		// Accessors
		uint back();			// Returns the ID of the vertex at the end of the path
		uint front();			// Returns the ID of the vertex at the front of the path
		int size();			// Returns the size of the path, in number of nodes
		double getLength(Graph &);	// Returns the length of the path in spatial units
		double getCoefficient(Graph &);	// Returns the trip coefficient of the path
			
		// Iterators
		listitr begin();	// Returns an iterator to the beginning of the list
		listitr end();		// Returns an iterator to the end of the list
				
		// Other methods
		void push_back(uint);		// Add a vertex to the end of the path
		bool contains(uint);		// Check if the path contains a certain vertex
		void clear();			// Clear the path list completely
		void incLength(double);		// Increase the length of the path
		void incCoefficient(double);	// Increase the trip coefficient

				
	protected:
		
		double length;		// Path length
		double coefficient;	// Path coefficient
		list <uint> path;	// Path description
};


#endif

I'm struggling to use my equals operator. I have a list <Paths> which contains path objects, and want to create a std::priority_queue <LanguagePaths>, like so :

Code:

    // Create a priority queue using specified comparison function
    priority_queue < LanguagePaths, vector <LanguagePaths>, PathCompare > pq(comparefunction);
    
    // Create a temp LanguagePaths object
    LanguagePaths temp;
    
    for(list<Paths>::iterator i = finallist.begin(); i != finallist.end(); i++)
    {
    	temp = *i;
    	pq.push(temp);
    }

I get these errors :

Code:

paths.h: In member function 'LanguagePaths LanguagePaths::operator=(const Paths&)':
paths.h:45: error: 'double Paths::length' is protected

I get the same error for Paths::coefficient and Paths::path.

I was under the impression that protected members of a base class could be accessed by a derived class. I'm not quite sure what I should be doing.

Any help would be greatly appreciated. Thanks very much !
Quentin

A LanguagePaths object can only access the protected members of other LanguagePaths objects, not any protected members of other classes with the same base class.

Because it takes a Paths object as an argument, LanguagePaths has no business messing around with it, or else it might be manipulating a completely unrelated object to itself.

You should try to use the public interface of Paths.

If I'm not mistaken, using protected members is a bit of an antipattern anyway: the base class can't enforce its invariants, because derived classes can manipulate it directly.

No, it can access the protected parts of other LanguagePath objects. If it could access protected members of any Paths objects, it would mean a LanguagePath could mess around with a SymbolPath or whatever other classes you derive from Paths.

Code:

class Base
{
    protected: int x;
};

class Child
{
     void ok(Child& child) { x = 20; child.x = 10; }
     void not_ok(Base& base) { base.x = 10; }
};

The point is that in

Code:

LanguagePaths LanguagePaths::operator=(const Paths & original)

you don't know what Paths is. It could be a reference to another LanguagePaths object, it could be a reference to another class derived from Paths to which LanguagePaths has no relation (except for common base class). Therefore the protected members of the original are unaccessible to the current LanguagePaths object.

Example:

Code:

#include <algorithm>

class Value
{
    protected:
        int x;
    public:
        int get_value() const { return x; }
};

class SingleDigitValue: public Value
{
    public:
        void set_value(int n)
        {
            x = std::max(std::min(9, n), 0);  //invariant, value always in certain range [0...9]
        }
};

class AnyValue: public Value
{
    public:
        void set_value(int n) { x = n; }
        void set_value_of(Value& v, int n)
        {
            v.x = n;  //your error
        }
};

int main()
{
    SingleDigitValue single;
    single.set_value(5);
    AnyValue any;
    any.set_value_of(single, 100);
    //it it worked single.x would now be 100, despite the restriction that it should be in range [0..9]
}