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