C / C++ / MFC

infectedprof wrote:

run in a powershell/terminal kind of environment.

class CValue
{
};

class CStringValue : public CValue
{
public:
    // CStringValue specific methods like void SetValue(const std::string&) and
    // const std::string& GetValue();
private:
    std::string m_Value;
};

class CIntValue : public CValue
{
public:
    // CIntValue specific methods like void SetValue(int) and
    // int GetValue();
private:
    int m_Value;
};

void SetValue(CValue* val);
CValue* GetValue();

class CStringValue;
class CIntValue;

class CValue
{
public:
    enum EType
    {
        EType_String,
        EType_Int,
    };
    virtual Etype GetType() = 0;

    // Downcast methods, not the most beautiful OO solution of the world but sometimes
    // in a fixed size class hierarchy like this it is acceptable and comfortable, and
    // more beautiful than using for example C++'s dynamic_cast. If quite comfortable
    // to say for example "if (CStringValue* sv = val->AsStringValue())"

    // override this only in CStringValue and put "return this;" into the method body.
    virtual CStringValue* AsStringValue() { return NULL; }
    // override this only in CIntValue and put "return this;" into the method body.
    virtual CIntValue* AsIntValue() { return NULL; }
};

class CValue
{
public:
    virtual std::string ToString() const = 0;
    virtual bool SetFromString(const std::string& s) = 0;

    // OK, lets support XML too...
    virtual void SaveToXml(XmlElement* node) = 0;
    virtual bool LoadFromXml(XmlElement* node) = 0;

    // TODO: put here your other useful utility virtual methods
};

class CValueVisitor;
class CValue
{
public:
    virtual void accept(CValueVisitor* visitor);
};

class CValueVisitor
{
public:
    virtual void visit(CStringValue* v) = 0;
    virtual void visit(CIntValue* v) = 0;
};

// App_Datatype.cpp : Defines the entry point for the console application.
//
#include <iostream>
#include <tchar.h>
#include <stdio.h>


class CStringValue;
class CValue
{
public:

	enum EType
    {
        EType_String,
        EType_Int,
    };


	virtual EType getDataType() = 0;

	virtual CStringValue* AsStringValue() { return NULL; }


};

class CStringValue : public CValue
{
private:
	std::string m_strValue;

public:

	void set(const std::string &strVal)
	{
		m_strValue = strVal;
	}

	std::string get()
	{
		return m_strValue;
	}

	CStringValue* AsStringValue()
	{
		return this;
	}

	EType getDataType()
	{
		return CValue::EType_String;
	}
};

void print(CValue *pVal)
{
	if(pVal->getDataType() == CValue::EType_String)
	{
		CStringValue *val = pVal->AsStringValue();
		std::cout<<val->get().c_str();
	}
}

int _tmain(int argc, _TCHAR* argv[])
{

	CStringValue *val = new CStringValue();
	val->set("Hai");

	print(val);

	return 0;
}

std::string get()
{
    return m_strValue;
}

<pre lang="c++">
    const std::string& get() const
    {
        return m_strValue;
    }
</pre>