Am I implementing the SOLID principles the right way? - solid-principles

Question

This is the first time I am writing a C++ code using SOLID principles. Therefore I do not know if the following sample code implements the principles correctly. My questions follow the code.
I highly appreciate all responses. Thanks!
Here is the sample:
class ICustomer
{
public:
virtual char* GetName() = 0;
virtual char* GetSurname() = 0;
virtual char* GetAddress() = 0;
};
class CCustomer : public ICustomer
{
public:
virtual char* GetName()
{
return "Name1";
}
virtual char* GetSurname()
{
return "Surname1";
}
virtual char* GetAddress()
{
return "Address1";
}
};
class IExporter
{
public:
virtual void Export() = 0;
};
class CExportToExcel : public IExporter
{
public:
virtual void Export()
{
ICustomer* pCustomer = new CCustomer;
printf("%s, %s, %s\n", pCustomer->GetName(), pCustomer->GetSurname(), pCustomer->GetAddress());
}
};
class IShopOwner
{
public:
virtual void Execute() = 0;
};
class CShopOwner : public IShopOwner
{
public:
virtual void Execute()
{
IExporter* pExp = new CExportToExcel;
pExp->Export();
}
};
void main()
{
IShopOwner* pOwner = new CShopOwner;
pOwner->Execute();
}
Questions:
Is it a valid SOLID implementation? If no, how it should be.
In the sample ICustomer has GetName(), GetSurname() and GetAddress(). I want an additional info GetPhoneNumber(). Where should I put that in? What changes will it incur?
In the sample there is CExportToExcel. Now I want an additional class CExportToHTML and use it. How should I do that?

Answer 1

The key feedback is to take the dependencies through the concrete class constructors, and take these dependencies as the interfaces not the concrete class, so .. In your object composition root you can decide which actual concrete implementation to pass on to create your objects, ie another product implementation of an interface or just a test mock class for testability purposes. it will also nicely fit with dependency injection pattern and frameworks.
as an example:
change your CShopOwner class to have a constructor that takes an IExporter object, keep that object as a property and use that inside your Execute method. When you are creating your CShopOwner object, on run time you can decide what exact concrete implementation of IExporter interface to pass it on ie. CExportToHTML.
This should cover your 1st and 3rd questions. About your second question. If GetPhoneNumber() would be relevant for all implementation s of ICustomer, puristically speaking you should create a new interface still, inheriting from ICustomer with one method - GetPhoneNumber() - and not change the ICustomer interface especially if it is already being used by client code because you are breaking the contract by changing it and may cause issues on the existing clients. On the other hand if you asses the situation and risk you could change the ICustomer interface directly and all consumers of it, if this is all your own code which will be much easier. we have all done it :)