Re: Is this kind of static polymorphism valid?
{ Please limit your quoting to the minimum needed to establish context
-mod }
On 2012-09-05 09:48, Daniel Kr?gler wrote:
[2nd attempt after 24 hours]
Am 03.09.2012 21:17, schrieb DeMarcus:
[..]
I'm experimenting with static polymorphism and came up with the
following. This example do run under gcc 4.7.1 but without luck
I've tried to find the paragraphs in the standard that allow this
kind of static polymorphism.
template<class T>
class Runner
{
public:
void run()
{
runPrivate();
}
private:
void runPrivate();
};
namespace
{
// (struct SomeRunnerLabel without declaration)
Runner<struct SomeRunnerLabel> r;
}
template<>
void Runner<SomeRunnerLabel>::runPrivate()
{
std::cout << "Static polymorphism" << std::endl;
}
int main( int argc, char* argv[] )
{
r.run();
return 0;
}
My questions are:
1. Am I allowed to use struct SomeRunnerLabel as I do here?
Yes.
SomeRunnerLabel is not even a forward declaration and it just
serves as a label to get the polymorphism. Does anyone know where
in the standard I can find the paragraph that allows this kind of
template argument?
I would start with 7.1.6.3 [dcl.type.elab] p2:
"3.4.4 describes how name lookup proceeds for the identifier in an
elaborated-type-specifier. [..] If the elaborated-type-specifier is
introduced by the class-key and this lookup does not find a
previously declared type-name, [..] the elaborated-type-specifier is
a declaration that introduces the class-name as described in 3.3.2."
3.4.4 [basic.lookup.elab] p2 says:
"If the elaborated-type-specifier has no nested-name-specifier, and
unless the elaborated-type-specifier appears in a declaration with
the following form:
class-key attribute-specifier-seqopt identifier ;
the identifier is looked up according to 3.4.1 but ignoring any
non-type names that have been declared. [..] If the
elaborated-type-specifier is introduced by the class-key and this
lookup does not find a previously declared type-name, [..] the
elaborated-type-specifier is a declaration that introduces the
class-name as described in 3.3.2."
Finally we have 3.3.2 [basic.scope.pdecl] p6:
"The point of declaration of a class first declared in an
elaborated-type-specifier is as follows:
? for a declaration of the form
class-key attribute-specifier-seqopt identifier ;
the identifier is declared to be a class-name in the scope that
contains the declaration, otherwise [..]"
3.4.1 does not apply, because we have no previously declared type of
that name, thus we follow this change and find that the effect is
that the name SomeRunnerLabel is introduced into the scope of the
unnamed namespace.
2. Is this kind of static polymorphism allowed at all? As we see,
the template parameter T is not used for anything but creating
multiple versions of the class, doing polymorphism on the
runPrivate() function. Also for this one I would be very happy if
someone could direct me to the paragraph that allows this kind of
polymorphism.
It depends what you want to do. If the unnamed namespace is part of
a shared header, different translation units will see different
SomeRunnerLabel and different objects r. Is this what you want?
Thanks for your thorough answer!
What I want to do is an ultra-light (syntax-wise) yet powerful TDD
framework. It looks like the following. It should compile but it's
possible that the self-registering doesn't run perfectly due to the
initialization order thing. This is just to show you the idea.
// ITestFixture.hpp
#pragma once
class ITestFixture
{
public:
virtual ~ITestFixture() {}
virtual void runAllTests() = 0;
};
// MyTestFixture.hpp
#pragma once
#include <vector>
#include <string>
#include <functional>
#include <iostream>
#include "ITestFixture.hpp"
extern std::vector<ITestFixture*> testFixtures;
template<class T>
class MyTestFixture : public ITestFixture
{
public:
MyTestFixture( const std::string& name )
{
// This is a self-registering object.
testFixtures.push_back( this );
std::cout << "Registering: " << name << std::endl;
}
virtual void runAllTests()
{
runTests();
}
protected:
void test( std::function<void()> function )
{
function();
}
private:
// To be specialized by static polymorphism.
void runTests();
};
// FreeFunctions1Test.cpp
// !!! NOTE, it's a CPP file !!!
//
// This file will be multiplied and specialized for all the
// different unit tests.
#include "MyTestFixture.hpp"
namespace
{
MyTestFixture<struct FreeFunctions> tst( "Free Functions 1" );
}
template<>
void MyTestFixture<FreeFunctions>::runTests()
{
test(
[&]
{
std::cout << "Test 1 for Free Functions 1" << std::endl;
});
test(
[&]
{
std::cout << "Test 2 for Free Functions 1" << std::endl;
});
}
// main.cpp
#include <vector>
#include "ITestFixture.hpp"
std::vector<ITestFixture*> testFixtures;
int main()
{
for( auto fixture : testFixtures )
fixture->runAllTests();
return 0;
}
The only thing that needs to be written to set up another test is the
code in FreeFunctions1Test.cpp that is an example for testing free
functions. The template argument to MyTestFixture could preferably be
the class that will be under test, but if there is no class involved,
like in the example here when we pretend to test free functions, we
can provide an elaborated-type-specifier.
It also seems that this elaborated-type-specifier can have the same
name in different cpp files without getting 'multiple definitions'
during linkage (I found the following).
?3.3.2/6 saying "-for an /elaborated-type-specifier/ of the form
/class-key identifier/ if the /elaborated-type-specifier/ is used in
[..] otherwise, except as a friend declaration, the identifier is
declared in the smallest namespace or block scope that contains the
declaration.
Is my interpretation of the standard correct if I say that as long as
the template is declared in an unnamed namespace then I can do the
specialization with the same elaborated-type-specifier name as in
another file (more or less the same as with variable names, right)?
Also another question I have is why I can't put the specialized
runTests() function within the unnamed namespace as well? I get the
following error from gcc 4.7.1.
error: specialization of ?void MyTestFixture<T>::runTests() [with T =
{anonymous}::FreeFunctions]? in different namespace [-fpermissive]
error: from definition of ?void MyTestFixture<T>::runTests() [with T =
{anonymous}::FreeFunctions]? [-fpermissive]
In member function ?void MyTestFixture<T>::runTests() [with T =
{anonymous}::FreeFunctions]?:
error: definition of ?void MyTestFixture<T>::runTests() [with T =
{anonymous}::FreeFunctions]::<lambda>::operator()() const? is not in
namespace enclosing ?MyTestFixture<T>::runTests() [with T =
{anonymous}::FreeFunctions]::<lambda>? [-fpermissive]
Thanks,
Daniel
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]