Re: How to elegantly store (and load) a string to (from) a file in
binary mode?
David F wrote:
Thanks to both of you. I was afraid that this is the case.
So anyway, I have tried to create Mystring to augment the
ability to save/load strings.
Deriving from std::string in order to provide loading/saving
seems like overkill. It's sufficient to write loading and
saving code for std::string in class' method, which is
responsible for serialization.
I am not too familiar with using dynamic polymorphism (inheritance)
becaused I used only static polymorphism (templates).
Anyway, for my limited purpose, I did the following tests which
I thought will be straight forward - I thought that a derived class/struct
inherite ALL the capabilities of the base class plus whatever other
capabilities I add to it. So here is a test program:
#include <string>
using namespace std;
struct Z : public string{};
struct MS : public string {
int save() {/*statements;*/ return 0;}
int load() {/*statements;*/ return 0;}
};
struct X{
MS s;
X():s(""){}; //first failure
}; //.\Test_2.cpp(10) : error C2664: 'MS::MS(const MS &)' : cannot convert parameter 1 from
'const char [1]' to 'const MS &'
// Reason: cannot convert from 'const char [1]' to 'const MS'
// No constructor could take the source type, or constructor overload resolution
was ambiguous
Constructors don't have names and cannot be inherited by
derived class. Derived class must declare and define its
constructors if special functionality is required. In your
case, `MS' class should provide constructor, which accepts
pointer to characters array, if you want to mimic
std::string behavior:
struct MS : public std::string
{
MS(const std::string::value_type* ptr)
: std::string(ptr) {}
}
//*************************************
void main(int ac, char* av[])
{
Z sz; // OK
sz="z"; // failed: Z didn't inherite the operator '=', and so on
MS s1; // OK
s1="a"; // failed
MS sm("L"); // failed
sm="K"; // failed
X s2; // OK
s2.s="b"; // failed
X sa("L"); // failed
sm="L"; // failed
}
Obviously I miss something very fundamental. Especially in the simplest possible
case of type Z, where I would think is a synonym to the type 'string'.
What is it?
Assignment to std::string derived classes fails to compile
because `std::string::operator =' is hidden by assignment
operator in derived class. Assignment operator (`operator
=') is a special member function. If developer doesn't
provide it, then compiler generates assignment operator
implicitly. That's why derived class always hides assignment
operator of base class.
HTH
Alex