结构和类在C ++中是否真的相同？

Question

Assuming that struct is similar to class except for the default member privacy, why the following code does not compile?

#define class struct
#include <iostream>


int main()
{
     return 0;
}

---

Update

In file included from /usr/include/c++/7/bits/stl_algobase.h:61:0,
                 from /usr/include/c++/7/vector:60,
                 from main.cpp:5:
/usr/include/c++/7/bits/cpp_type_traits.h:86:18: error: ‘struct std::_Sp’ is not a valid type for a template non-type parameter
   template<class _Sp, class _Tp>
                  ^~~
compilation terminated due to -Wfatal-errors.

Answer 1

The behaviour of your code is undefined : The C++ standard does not permit the redefinition of keywords.

Perhaps the specific failure is due to template<class T> being valid syntax but template<struct T> is not? The preprocessor step seems to have ruined the implementation of <iostream> on your platform.

(A class and struct are the same in all respects aside from the default access of member variables and functions - including inheritance, as you point out.

The C++ standard allows you to forward declare as a struct and implement as a class and vice-versa, although some compilers; older versions of MSVC for example; disallow that.)

Answer 2

A class and a struct are equivalent (except for the default privacy)

but grammar doesn't allow struct in template:

 template <struct S> // Invalid
 /*..*/

whereas

 template <class C> // valid
 /*..*/

or

 template <typename T> // valid
 /*..*/

Answer 3

The behavior is identical when defining members.

However, class and struct are not synonymous in every context.

template<class T> is a synonym for template <typename T> . Your #define would turn it into template <struct T> , which is not allowed. I presume this is why you're getting errors on templates in the standard headers.

Answer 4

In addition to other answers,

To hack into a private visibility scope, the least intrusive way is probably to copy the header to your code base (making sure it goes first in the -I path), and make one of your classes a friend of the third party API class that needs hacking. This would be my tool to temporarily patching a suboptimal third party API for production usage.

Another, a more "cowboy" way is to #define private public for some limited scope. This one I would not do in a production code base, probably.