Question

PREFACE: I’m relatively inexperienced in C++ so this very well could be a Day 1 n00b question.

I’m working on something whose long term goal is to be portable across multiple operating systems. I have the following files:

Utilities.h

#include <string>

class Utilities
{
public:
    Utilities() { };
    virtual ~Utilities() { };

    virtual std::string ParseString(std::string const& RawString) = 0;
};

UtilitiesWin.h (for the Windows class/implementation)

#include <string>
#include "Utilities.h"

class UtilitiesWin : public Utilities
{
public:
    UtilitiesWin() { };
    virtual ~UtilitiesWin() { };

    virtual std::string ParseString(std::string const& RawString);
};

UtilitiesWin.cpp

#include <string>
#include "UtilitiesWin.h"

std::string UtilitiesWin::ParseString(std::string const& RawString)
{
    // Magic happens here!
    // I'll put in a line of code to make it seem valid
    return "";
}

So then elsewhere in my code I have this

#include <string>
#include "Utilities.h"

void SomeProgram::SomeMethod()
{
    Utilities *u = new Utilities();
    StringData = u->ParseString(StringData); // StringData defined elsewhere
}

The compiler (Visual Studio 2008) is dying on the instance declaration

c:\somepath\somecode.cpp(3) : error C2259: 'Utilities' : cannot instantiate abstract class
        due to following members:
        'std::string Utilities::ParseString(const std::string &)' : is abstract
        c:\somepath\utilities.h(9) : see declaration of 'Utilities::ParseString'

So in this case what I’m wanting to do is use the abstract class (Utilities) like an interface and have it know to go to the implemented version (UtilitiesWin).

Obviously I’m doing something wrong but I’m not sure what. It occurs to me as I’m writing this that there’s probably a crucial connection between the UtilitiesWin implementation of the Utilities abstract class that I’ve missed, but I’m not sure where. I mean, the following works

#include <string>
#include "UtilitiesWin.h"

void SomeProgram::SomeMethod()
{
    Utilities *u = new UtilitiesWin();
    StringData = u->ParseString(StringData); // StringData defined elsewhere
}

but it means I’d have to conditionally go through the different versions later (i.e., UtilitiesMac(), UtilitiesLinux(), etc.)

What have I missed here?

Answer 1

Utilities *u = new Utilities();

tells the compiler to make a new instance of the Utilities class; the fact that UtilitiesWin extends it isn’t necessarily known and doesn’t affect it. There could be lots of classes extending Utilities, but you told the compiler to make a new instance of Utilities, not those subclasses.

It sounds like you want to use the factory pattern, which is to make a static method in Utilities that returns a Utilities* that points to a particular instance:

static Utilities* Utilities::make(void) {return new UtilitiesWin();}

At some point you’re going to have to instantiate a non-abstract subclass; there’s no way around specifying UtilitiesWin at that point