C style use of a modern C++ class

Question

I have a class like so:

Snippet 1:

struct B
{
    int member;
    // more complex members e.g. arrays of structs etc
};

This class is used in the code assuming it is a C style struct (e.g. used in memcpy, memset etc)

As part of good programming principles, I am contemplating modifying B like so:

Snippet 2

struct B 
{
    B() {}
    int member;
    // more complex members e.g. arrays of structs etc
};

Here is my understanding. Please correct if I got this wrong a. Snippet 1 defines B which is a POD whereas Snippet 2 defines B which is not a POD, AND b. In Snippet 2, B can still be legitimately used for C style uses such as memset and memcpy

1. std::is_pod : false
2. std::is_trivial : false
3. std::is_trivially_copyable : true
4. std::is_trivial : false

Extending, I would also follow the rule of Big 3 (or perhaps Big 5), I would add copy assignment as well as copy constructor.

Snippet 3:

struct B
{
    B() {}
    ~B(){}
    B& operator=(B &){ return *this; }
    B(B const &r){}
    int member;

    // more complex members e.g. arrays of structs etc
};

Here is my understanding. Please correct if I got this wrong a. In Snippet 3, B can now no longer be legitimately used for C style uses such as memset and memcpy

1. std::is_pod : false
2. std::is_trivial : false
3. std::is_trivially_copyable : false
4. std::is_trivial : false

I need understanding on the effect of adding various members to B in Snippet 2 and Snippet 3 on C style uses of B.

Is the C Style use of a class really based on is_trivially_copyable or on is_trivial (which is more restrictive)?

Reading $3.9/2 indicates to me that in C++11 "is_trivially_copyable" is really the determining criteria. Some old C++ books (C++ in a nutshell e.g.) however indicate the criteria is about POD vs non POD and I understand that C++11 rules have changed since.

Petes response seems to indicate that trivial-ness is the necessary criteria

Answer 1

If your struct only contains POD data members, and is not responsible for managing any resources, such as dynamically allocated memory, there's absolutely no reason to define the destructor, copy constructor and assignment operators. At most I'd add a constructor to initialize the data members. And with C++11, this can be done trivially using non-static data member initializers.

struct B
{
    int member = 0; // this will initialize the data member to 0
};

You could also add a constructor that takes an int and allows you to initialize member to any desired value. In that case

struct B
{
    int member;
    explicit B(int member = 0) : member(member) {}
};

Both of these changes will leave your class trivially copyable (9/6) and standard layout (9/7), which means you'll be able to use them with C-style functions.

---

From the discussion in the comments, it seems you're not necessarily interested in being able to initialize all data members, but still want to provide a default constructor.

struct B 
{
    B() {}
    int member;
    // more complex members e.g. arrays of structs etc
};

This is a bad idea because it doesn't add anything useful to the class, and makes it non-trivial because it now has a non-trivial default constructor. If you really want to define a default constructor, you should explicitly default it instead.

struct B 
{
    B() = default;
    int member;
    // more complex members e.g. arrays of structs etc
};

This leaves the class trivial, and standard layout, allowing you to use it with C style functions.