{"id":1151,"date":"2013-07-18T01:00:00","date_gmt":"2013-07-17T23:00:00","guid":{"rendered":"https:\/\/www.fussylogic.co.uk\/blog\/?p=1151"},"modified":"2013-07-20T12:34:15","modified_gmt":"2013-07-20T11:34:15","slug":"cloners","status":"publish","type":"post","link":"https:\/\/www.fussylogic.co.uk\/blog\/?p=1151","title":{"rendered":"Cloners"},"content":{"rendered":"

Let\u00e2\u20ac\u2122s say we are reading tagged blocks from within some sort of packet. The blocks being tagged means we won\u00e2\u20ac\u2122t care whether they\u00e2\u20ac\u2122re present, what order they come in, and can have each tag be a different length.<\/p>\n

<tag2> <tag2_data0> <tag2_data1> ... <tag2_data11>\n<tag1> <tag1_data0> <tag1_data1> ... <tag1_data8>\n<tag6> <tag6_data0> <tag6_data1> ... <tag6_data20>\n<tag3> <tag3_data0> <tag3_data1> ... <tag3_data6>\n<tag0> <tag0_data0> <tag0_data1> ... <tag0_data10>\n<tag5> <tag5_data0> <tag5_data1> ... <tag5_data7>\n<tag4> <tag4_data0> <tag4_data1> ... <tag4_data3><\/code><\/pre>\n
Each tag might represent data for a particular sensor, say.<\/p>\n
We want to write an object-oriented reader. Let\u00e2\u20ac\u2122s first consider a naive implementation:<\/p>\n
    list<TTag*> TagList;\n    while<\/span>(stream) {\n        tag_code = stream.read(1<\/span>);\n        switch<\/span>( tag_code ) {\n            case<\/span> tag_0:\n                TagList.push_back(new TTag0);\n                break<\/span>;\n            case<\/span> tag_1:\n                TagList.push_back(new TTag1);\n                break<\/span>;\n            \/\/ ... etc ...<\/span>\n            default<\/span>:\n                throw tag_read_error();\n                break<\/span>;\n        }\n        TagList.back().read(stream);\n    }<\/code><\/pre>\n
We\u00e2\u20ac\u2122ve made the tag objects derive from TTag<\/code>, and each implements a virtual read()<\/code> member that knows how to read itself from a stream. The tag will know its own length, so will leave the stream pointing at the next tag_code<\/code>.<\/p>\n
It\u00e2\u20ac\u2122s a naive implementation because it\u00e2\u20ac\u2122s putting information about the tag, outside the TTag<\/code> object \u00e2\u20ac\u201c i.e.\u00c2\u00a0the tag_code<\/code>. We shouldn\u00e2\u20ac\u2122t break layering by having any knowledge of the code outside the TTag child. Let\u00e2\u20ac\u2122s make an improvement then:<\/p>\n
    tag_code = stream.read(1<\/span>);\n    switch<\/span>( tag_code ) {\n        case<\/span> TTag0::tag_code:\n            TTagList.push_back(new TTag0);\n        case<\/span> TTag1::tag_code:\n            TTagList.push_back(new TTag1);\n        \/\/ ... etc ...<\/span>\n    }<\/code><\/pre>\n
This is better, but not much. We\u00e2\u20ac\u2122ve made a little use of object orientation, but not enough. In fact, as a rule, any time you see a switch()<\/code> in C++, you should ask whether or not you can push what its doing into an object.<\/p>\n
Here\u00e2\u20ac\u2122s a solution I end up using a lot. This code would go in some sort of factory class:<\/p>\n
    list<const<\/span> TTag*> TagTemplates;\n    TagTemplate.push_back(new TTag0);\n    TagTemplate.push_back(new TTag2);\n    \/\/ ... etc ...<\/span>\n    TagTemplate.push_back(new TTag6);\n\n    list<TTag*> TagList;\n    tag_code = stream.read(1<\/span>);\n    for<\/span>( auto<\/span> tag : TagTemplates ) {\n        if<\/span>( tag->isThisYourCode(tag_code) ) {\n            TagList.push_back(tag);\n            tag->read(stream);\n        }\n    }<\/code><\/pre>\n
Very nice. We\u00e2\u20ac\u2122ve replaced a hard-coded list, with an iteration. The template tags can be loaded elsewhere (probably the factory constructor) and could be different for different factory classes. The problem is that the above won\u00e2\u20ac\u2122t work. In particular note:<\/p>\n
    TagList.push_back(tag);\n    tag->read(stream);<\/code><\/pre>\n
Here tag<\/code> is a const TTag*<\/code> from the TagTemplate<\/code> list; and is being pushed onto a TTag*<\/code> list. The compiler will block it. Worse, we\u00e2\u20ac\u2122re trying to read from the stream into our one-and-only template TTag<\/code>. What we need instead is the ability to copy the tag template to give us a modifiable instance that is independent.<\/p>\n
That poses its own difficulty. What we have is a const TTag*<\/code>, point at (say) a TTag0<\/code>, we might wish we could do this:<\/p>\n
    TTag *copyTag = new TTag;\n    *copyTag = *tag;<\/code><\/pre>\n
This absolutely won\u00e2\u20ac\u2122t work. We\u00e2\u20ac\u2122ve made a new TTag<\/code>, when we wanted a TTag0<\/code>. We probably won\u00e2\u20ac\u2122t even get as far as compilation because TTag<\/code> is bound to be abstract, and so it\u00e2\u20ac\u2122s not possible to make a new<\/code> one. Even if we could, *copyTag = *tag<\/code> would use TTag::operator=()<\/code> not TTag0::operator=()<\/code>. In short: a mess.<\/p>\n
The solution in cases like this is to think about what it is you want: the ability to copy a derived class via a pointer with base-class type. Just like any other operation where we have a base-class pointer to access derived-class functionality, we use a virtual. This is often called the Virtual Constructor Idiom<\/em><\/a>.<\/p>\n
class TTag {\n  public:\n    virtual TTag *clone() const<\/span> = 0<\/span>;\n};\n\nclass TTag0 {\n  public:\n    TTag0(const<\/span> TTag&) { \/* ... your implementation ... *\/<\/span> }\n    TTag0 *clone() const<\/span> override { return<\/span> new TTag0(*this); }\n};<\/code><\/pre>\n
Some points:<\/p>\n