Paradigm for Internally Swapping Child Type
Let's say that I have this:
struct Base {
virtual void swap();
Expensive mem;
};
struct Left : Base {
void swap() override;
};
struct Right : Base {
void swap() override;
};
Given a vector<shared_ptr<Base>> foo which contains Left and Right objects. Lets say element 13 was a Left now I want it to be a Right. I can do something like:
foo[13] = make_shared<Right>();
But now let's suppose that Expensive is very costly to construct or copy, and let's suppose that Left and Right contain no members of their own, they are simply a different way of manipulating and interpreting mem. Is there a way that I can cast or tell element 13 that it is now a Right without destroying the Left that was there? Could I use enable_shared_from_this or similar to manipulate the destruction and reconstruction to where I could call foo[13].swap() and it would "become" a Right?
c++ inheritance types polymorphism siblings
asked Nov 13 '18 at 22:12
Jonathan MeeJonathan Mee
21.6k1064167
add a comment |
Let's say that I have this:
struct Base {
virtual void swap();
Expensive mem;
};
struct Left : Base {
void swap() override;
};
struct Right : Base {
void swap() override;
};
Given a vector<shared_ptr<Base>> foo which contains Left and Right objects. Lets say element 13 was a Left now I want it to be a Right. I can do something like:
foo[13] = make_shared<Right>();
But now let's suppose that Expensive is very costly to construct or copy, and let's suppose that Left and Right contain no members of their own, they are simply a different way of manipulating and interpreting mem. Is there a way that I can cast or tell element 13 that it is now a Right without destroying the Left that was there? Could I use enable_shared_from_this or similar to manipulate the destruction and reconstruction to where I could call foo[13].swap() and it would "become" a Right?
c++ inheritance types polymorphism siblings
asked Nov 13 '18 at 22:12
Jonathan MeeJonathan Mee
21.6k1064167
add a comment |
Let's say that I have this:
struct Base {
virtual void swap();
Expensive mem;
};
struct Left : Base {
void swap() override;
};
struct Right : Base {
void swap() override;
};
Given a vector<shared_ptr<Base>> foo which contains Left and Right objects. Lets say element 13 was a Left now I want it to be a Right. I can do something like:
foo[13] = make_shared<Right>();
But now let's suppose that Expensive is very costly to construct or copy, and let's suppose that Left and Right contain no members of their own, they are simply a different way of manipulating and interpreting mem. Is there a way that I can cast or tell element 13 that it is now a Right without destroying the Left that was there? Could I use enable_shared_from_this or similar to manipulate the destruction and reconstruction to where I could call foo[13].swap() and it would "become" a Right?
c++ inheritance types polymorphism siblings
asked Nov 13 '18 at 22:12
Jonathan MeeJonathan Mee
21.6k1064167
Let's say that I have this:
struct Base {
virtual void swap();
Expensive mem;
};
struct Left : Base {
void swap() override;
};
struct Right : Base {
void swap() override;
};
Given a vector<shared_ptr<Base>> foo which contains Left and Right objects. Lets say element 13 was a Left now I want it to be a Right. I can do something like:
foo[13] = make_shared<Right>();
But now let's suppose that Expensive is very costly to construct or copy, and let's suppose that Left and Right contain no members of their own, they are simply a different way of manipulating and interpreting mem. Is there a way that I can cast or tell element 13 that it is now a Right without destroying the Left that was there? Could I use enable_shared_from_this or similar to manipulate the destruction and reconstruction to where I could call foo[13].swap() and it would "become" a Right?
c++ inheritance types polymorphism siblings
c++ inheritance types polymorphism siblings
asked Nov 13 '18 at 22:12
Jonathan MeeJonathan Mee
21.6k1064167
asked Nov 13 '18 at 22:12
Jonathan MeeJonathan Mee
21.6k1064167
asked Nov 13 '18 at 22:12
Jonathan MeeJonathan Mee
21.6k1064167
asked Nov 13 '18 at 22:12
Jonathan MeeJonathan Mee
21.6k1064167
asked Nov 13 '18 at 22:12
Jonathan MeeJonathan Mee
21.6k1064167
21.6k1064167
add a comment |
add a comment |
1 Answer
1
active
oldest
votes
Well, you could consider making Left and Right the same type. But if you can't do that, then you can still take advantage of move semantics. Assume Expensive is cheaply movable. Then you could do something like this:
struct Base {
Base(Expensive mem) : mem(std::move(mem)) {}
virtual std::shared_ptr<Base> swap() = 0;
Expensive mem;
};
struct Left : Base {
Left(Expensive mem) : Base(std::move(mem)) {}
std::shared_ptr<Base> swap() override;
};
struct Right : Base {
Right(Expensive mem) : Base(std::move(mem)) {}
std::shared_ptr<Base> swap() override;
};
std::shared_ptr<Base> Left::swap() {
return std::make_shared<Right>(std::move(mem));
}
std::shared_ptr<Base> Right::swap() {
return std::make_shared<Left>(std::move(mem));
}
// ...
foo[13] = foo[13]->swap();
(Note that destruction of the original object pointed to by foo[13] doesn't occur until the body of std::shared_ptr<Base>::operator= is entered, by which time swap() will have completed and left mem in a destructible state, so it seems to me that this code would be well-defined).
answered Nov 13 '18 at 22:24
BrianBrian
64.3k795182
add a comment |
Your Answer
StackExchange.ifUsing("editor", function () {
StackExchange.using("externalEditor", function () {
StackExchange.using("snippets", function () {
StackExchange.snippets.init();
});
});
}, "code-snippets");
StackExchange.ready(function() {
var channelOptions = {
tags: "".split(" "),
id: "1"
};
initTagRenderer("".split(" "), "".split(" "), channelOptions);
StackExchange.using("externalEditor", function() {
// Have to fire editor after snippets, if snippets enabled
if (StackExchange.settings.snippets.snippetsEnabled) {
StackExchange.using("snippets", function() {
createEditor();
});
}
else {
createEditor();
}
});
function createEditor() {
StackExchange.prepareEditor({
heartbeatType: 'answer',
autoActivateHeartbeat: false,
convertImagesToLinks: true,
noModals: true,
showLowRepImageUploadWarning: true,
reputationToPostImages: 10,
bindNavPrevention: true,
postfix: "",
imageUploader: {
brandingHtml: "Powered by u003ca class="icon-imgur-white" href="https://imgur.com/"u003eu003c/au003e",
contentPolicyHtml: "User contributions licensed under u003ca href="https://creativecommons.org/licenses/by-sa/3.0/"u003ecc by-sa 3.0 with attribution requiredu003c/au003e u003ca href="https://stackoverflow.com/legal/content-policy"u003e(content policy)u003c/au003e",
allowUrls: true
},
onDemand: true,
discardSelector: ".discard-answer"
,immediatelyShowMarkdownHelp:true
});
}
});
Sign up or log in
StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
StackExchange.ready(
function () {
StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fstackoverflow.com%2fquestions%2f53290296%2fparadigm-for-internally-swapping-child-type%23new-answer', 'question_page');
}
);
Post as a guest
Required, but never shown
1 Answer
1
active
oldest
votes
1 Answer
1
active
oldest
votes
active
oldest
votes
active
oldest
votes
Well, you could consider making Left and Right the same type. But if you can't do that, then you can still take advantage of move semantics. Assume Expensive is cheaply movable. Then you could do something like this:
struct Base {
Base(Expensive mem) : mem(std::move(mem)) {}
virtual std::shared_ptr<Base> swap() = 0;
Expensive mem;
};
struct Left : Base {
Left(Expensive mem) : Base(std::move(mem)) {}
std::shared_ptr<Base> swap() override;
};
struct Right : Base {
Right(Expensive mem) : Base(std::move(mem)) {}
std::shared_ptr<Base> swap() override;
};
std::shared_ptr<Base> Left::swap() {
return std::make_shared<Right>(std::move(mem));
}
std::shared_ptr<Base> Right::swap() {
return std::make_shared<Left>(std::move(mem));
}
// ...
foo[13] = foo[13]->swap();
(Note that destruction of the original object pointed to by foo[13] doesn't occur until the body of std::shared_ptr<Base>::operator= is entered, by which time swap() will have completed and left mem in a destructible state, so it seems to me that this code would be well-defined).
answered Nov 13 '18 at 22:24
BrianBrian
64.3k795182
add a comment |
Well, you could consider making Left and Right the same type. But if you can't do that, then you can still take advantage of move semantics. Assume Expensive is cheaply movable. Then you could do something like this:
struct Base {
Base(Expensive mem) : mem(std::move(mem)) {}
virtual std::shared_ptr<Base> swap() = 0;
Expensive mem;
};
struct Left : Base {
Left(Expensive mem) : Base(std::move(mem)) {}
std::shared_ptr<Base> swap() override;
};
struct Right : Base {
Right(Expensive mem) : Base(std::move(mem)) {}
std::shared_ptr<Base> swap() override;
};
std::shared_ptr<Base> Left::swap() {
return std::make_shared<Right>(std::move(mem));
}
std::shared_ptr<Base> Right::swap() {
return std::make_shared<Left>(std::move(mem));
}
// ...
foo[13] = foo[13]->swap();
(Note that destruction of the original object pointed to by foo[13] doesn't occur until the body of std::shared_ptr<Base>::operator= is entered, by which time swap() will have completed and left mem in a destructible state, so it seems to me that this code would be well-defined).
answered Nov 13 '18 at 22:24
BrianBrian
64.3k795182
add a comment |
Well, you could consider making Left and Right the same type. But if you can't do that, then you can still take advantage of move semantics. Assume Expensive is cheaply movable. Then you could do something like this:
struct Base {
Base(Expensive mem) : mem(std::move(mem)) {}
virtual std::shared_ptr<Base> swap() = 0;
Expensive mem;
};
struct Left : Base {
Left(Expensive mem) : Base(std::move(mem)) {}
std::shared_ptr<Base> swap() override;
};
struct Right : Base {
Right(Expensive mem) : Base(std::move(mem)) {}
std::shared_ptr<Base> swap() override;
};
std::shared_ptr<Base> Left::swap() {
return std::make_shared<Right>(std::move(mem));
}
std::shared_ptr<Base> Right::swap() {
return std::make_shared<Left>(std::move(mem));
}
// ...
foo[13] = foo[13]->swap();
(Note that destruction of the original object pointed to by foo[13] doesn't occur until the body of std::shared_ptr<Base>::operator= is entered, by which time swap() will have completed and left mem in a destructible state, so it seems to me that this code would be well-defined).
answered Nov 13 '18 at 22:24
BrianBrian
64.3k795182
Well, you could consider making Left and Right the same type. But if you can't do that, then you can still take advantage of move semantics. Assume Expensive is cheaply movable. Then you could do something like this:
struct Base {
Base(Expensive mem) : mem(std::move(mem)) {}
virtual std::shared_ptr<Base> swap() = 0;
Expensive mem;
};
struct Left : Base {
Left(Expensive mem) : Base(std::move(mem)) {}
std::shared_ptr<Base> swap() override;
};
struct Right : Base {
Right(Expensive mem) : Base(std::move(mem)) {}
std::shared_ptr<Base> swap() override;
};
std::shared_ptr<Base> Left::swap() {
return std::make_shared<Right>(std::move(mem));
}
std::shared_ptr<Base> Right::swap() {
return std::make_shared<Left>(std::move(mem));
}
// ...
foo[13] = foo[13]->swap();
(Note that destruction of the original object pointed to by foo[13] doesn't occur until the body of std::shared_ptr<Base>::operator= is entered, by which time swap() will have completed and left mem in a destructible state, so it seems to me that this code would be well-defined).
answered Nov 13 '18 at 22:24
BrianBrian
64.3k795182
answered Nov 13 '18 at 22:24
BrianBrian
64.3k795182
answered Nov 13 '18 at 22:24
BrianBrian
64.3k795182
answered Nov 13 '18 at 22:24
BrianBrian
64.3k795182
64.3k795182
add a comment |
add a comment |
Thanks for contributing an answer to Stack Overflow!
- Please be sure to answer the question. Provide details and share your research!
But avoid …
- Asking for help, clarification, or responding to other answers.
- Making statements based on opinion; back them up with references or personal experience.
To learn more, see our tips on writing great answers.
Sign up or log in
StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
StackExchange.ready(
function () {
StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fstackoverflow.com%2fquestions%2f53290296%2fparadigm-for-internally-swapping-child-type%23new-answer', 'question_page');
}
);
Post as a guest
Required, but never shown
Sign up or log in
StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
Sign up or log in
StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
Sign up or log in
StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
