Yhyjyk

Sometimes it can be an annoyance that c++ defaults to allow slicing. For example

#include <iostream>
struct foo int a; ;
struct bar : foo int b; ;

int main() 
 bar x1,2;
 foo y = x; // <- I dont want this to compile!

This compiles and runs as expected! Though, what if I dont want to enable slicing?

What is the idomatic way to write foo such that one cannot slice instances of any derived class?

I'm not sure if there is a named idiom for it but you can add a deleted function to the overload set that is a better match then the base classes slicing operations. If you change foo to

struct foo 
 
 int a; 
 foo() = default; // you have to add this because of the template constructor

 template<typename T>
 foo(const T&) = delete; // error trying to copy anything but a foo

 template<typename T>
 foo& operator=(const T&) = delete; // error assigning anything else but a foo
;

then you can only ever copy construct or copy assign a foo to foo. Any other type will pick the function template and you'll get an error about using a deleted function. This does mean that your class, and the classes that use it can no longer be an aggregate though. Since the members that are added are templates, they are not considered copy constructors or copy assignment operators so you'll get the default copy and move constructors and assignment operators.

You can prevent the base from being copied outside of member functions of derived classes and the base itself by declaring the copy constructor protected:

struct foo 
 // ...
protected:
 foo(foo&) = default;
;

Since 2011, the idiomatic way has been to use auto:

#include <iostream>
struct foo int a; ;
struct bar : foo int b; ;

int main() 
 bar x1,2;
 auto y = x; // <- y is a bar

If you wish to actively prevent slicing, there are a number of ways:

Usually the most preferable way, unless you specifically need inheritance (you often don't) is to use encapsulation:

#include <iostream>

struct foo int a; ;
struct bar 
 
 bar(int a, int b)
 : foo_(a)
 , b(b)
 

 int b; 

 int get_a() const return foo_.a; 

private:
 foo foo_;
;

int main() 
 bar x1,2;
// foo y = x; // <- does not compile

Another more specialised way might be to alter the permissions around copy operators:

#include <iostream>

struct foo 
 int a; 
protected:
 foo(foo const&) = default;
 foo(foo&&) = default;
 foo& operator=(foo const&) = default;
 foo& operator=(foo&&) = default;

;

struct bar : foo
 
 bar(int a, int b) 
 : fooa, bb
 

 int b; 
;

int main() 
 auto x = bar (1,2);
// foo y = x; // <- does not compile