Enforce rule of three or rule of five for future ESBMC extensions?

[kunjsong01]

Shall we enforce the C++ rule of three for future ESBMC development? If smart pointers are used, perhaps escalate it to rule of five?

And explicitly add default/delete copy constructors and copy assignment operators in the class, so that the compiler would report error when a shallow copy is about to happen in the code changes. This would save us lots of debugging time, and prevent unexpected failure due to shallow copy.

[rafaelsamenezes]

Is there any static analysis tool that can help us to ensure this rule?

[kunjsong01]

clang-tidy seems to have check for this rule. (https://sbmueller.github.io/posts/clang/)

[rafaelsamenezes]

clang-tidy seems to have check for this rule. (https://sbmueller.github.io/posts/clang/)

That would nice, we already have support for it in the CI.

• Clang-Tidy reported issues #561
• Define clang-tidy best flags #224

[lucasccordeiro]

Shall we enforce the C++ rule of three for future ESBMC development?
If smart pointers are used, perhaps escalate it to rule of five?

Yes. Yes. I agree with these suggestions :-)

[fbrausse]

Shall we enforce the C++ rule of three for future ESBMC development? If smart pointers are used, perhaps escalate it to rule of five?

Definitely yes!

And explicitly add default/delete copy constructors and copy assignment operators in the class, so that the compiler would report error when a shallow copy is about to happen in the code changes. This would save us lots of debugging time, and prevent unexpected failure due to shallow copy.

Can you elaborate how adding defaulted constructors/operators help in that regard? Deleted ones and defaulted copy when move is defined, sure, because they are required for the correct behaviour. But for example

struct A {
  A(const A &) = default;
  A(A &&) = default;
  A & operator=(const A &) = default;
  A & operator=(A &&) = default;
};

seems pointless.

[fbrausse]

This is the version of the "rule of 5" I usually try to adhere to:

struct A {
  A(const A &);
  A(A &&);
  friend void swap(A &a, A &b) { using std::swap; /* swap() all members */ }
  A & operator=(A a /* by-value */) { swap(*this, a); return *this; }
};

It keeps working if either constructor is removed, too + provides swap() more or less for free.