Let A be an abstract class in C++:
// legal
class A {
virtual void m() = 0;
}
It is illegal, of course, to define a variable whose type is an abstract class:
A a; // illegal
Indeed, clang 3.6.0 complains thus:
wat.cc:5:3: error: variable type 'A' is an abstract class
A a;
^
wat.cc:2:16: note: unimplemented pure virtual method 'm' in 'A'
virtual void m() = 0;
^
1 error generated.
Likewise, it is illegal to define a function with a parameter whose type is an abstract class:
void f(A a) {} // illegal
Indeed, clang complains thus:
wat.cc:5:10: error: parameter type 'A' is an abstract class
void f(A a) {}
^
wat.cc:2:16: note: unimplemented pure virtual method 'm' in 'A'
virtual void m() = 0;
^
1 error generated.
On the other hand, it is legal, of course, to define a variable whose type is a pointer to values of an abstract class:
A * a_ptr; // legal
Even if that class never had any base classes defined, the type A * has at least one value, nullptr, so it is always possible to use such a variable in a type-correct way, even if it’s probably not very useful unless A at some point gets some concrete subclasses:
a_ptr = nullptr; // legal
Presumably, this reasoning applies to any pointer type.
Likewise, it is legal to define a function taking a parameter whose type is a pointer to values of an abstract class:
void f(A * a) {} // legal
Likewise, it is legal to define a function taking a parameter whose type is a pointer to functions taking a parameter whose type is a pointer to values of an abstract class:
void f(void (* g)(A *)) {} // legal
Both of these functions, of course, can be called legally:
f(nullptr); // legal
Presumably, the specific type of the function parameter is irrelevant to the correctness of the type as long as it’s a pointer type. That call to f should be legal in either case. In terms of type theory, well-formed pointer types are always legal and nullptr always inhabits them. By this reasoning, this definition should be presumed legal:
void f(void (* g)(A)) {}
f is a function that takes a parameter whose type is a pointer to functions that take a parameter whose type is a value of the abstract class A.
Indeed, the only possible value for that parameter is nullptr, since no actual function can take a parameter whose type is an abstract class.
Is this legal per the C++ standard?
Clang complains:
wat.cc:5:20: error: parameter type 'A' is an abstract class
void f(void (* g)(A)) {}
^
wat.cc:2:16: note: unimplemented pure virtual method 'm' in 'A'
virtual void m() = 0;
^
1 error generated.
GCC doesn’t.
Update: This question was correctly answered, but the question itself is wrong in stating Clang accepts that function. Both GCC and Clang yield similar errors with this code. However, Clang accepts such functions if they are member functions. This works:
#include <iostream>
struct A {
virtual ~A() = 0;
};
struct B {
void f(void (*g)(A)) {
std::cout << "Works!" << std::endl;
}
};
int main() {
B().f(nullptr);
return 0;
}
This seems to be simply a bug in Clang, though. According to the language in the section of the standard cited in the accepted answer, this code should be rejected.
[class.abstract]/3 says: