Re: Bug with Visual Studio Optimizer?
On 4 Dez., 19:15, Greg Herlihy <gre...@mac.com> wrote:
Functions are not objects in C++ - so there is no guarantee that a
unique function name must refer to its own, unique function. In the
original example, it is clear that foo<int> and foo<float> have
identical signatures and identical implementations. From both a
mathematical point of view, fool<float> and foo<int> are the same
function. Likewise, a C++ compiler can certainly consider the two to
name the same function as well.
So the error in this case is not a bug in the C++ compiler, instead
the error is the mistaken assumption that foo<int> and foo<float> must
refer to two different functions. They do not.
It *is* a compiler error, because both specializations
belong to functions which are *not* the same. This can
be clearly seen via the following argumentation chain:
[expr.eq]/1:
"[..] Two pointers of the same type compare equal if and
only if they are both null, both point to the same function,
or both represent the same address (3.9.2)."
For the discussion it is *only* relevant, that both
functions are not the same, it is *not* relevant whether
they have the same address or not. Fact is that different
functions must *not* return true using ==. [Some restrictions
apply to non-external inline functions, but these are
*not* relevant here, because the discussed function template
is neither inline nor not-external]
[temp.type]/1:
"Two template-ids refer to the same class or function if their
template names are identical, they refer to the same template,
their type template-arguments are the same type, [..]"
Here we go: foo<float>() and foo<int> are *not* the same
functions according to this definition, because we have
in one case T=float and in another T=int.
The essential point for nominating this behaviour a bug
is the fact that the programs makes the logical not-
sameness between both functions observable via the ==
test and the compiler does not take this into account.
If the e.g. the program would use the function addresses
in other ways, where discrimination is not observable,
the compiler *is* allowed to do anything it wants to
optimize the program and *can* e.g. merge all functions
into one instance. Given
#include <iostream>
#include <ostream>
template<typename Type>
void foo() {
std::cout << "foo<>" << std::endl;
}
typedef void (*PF)();
int main() {
PF f[] = { foo<int>, foo<float>, foo<bool> };
for (int i = 0; i != sizeof(f)/sizeof(f[0]); ++i) {
f[i]();
}
}
a legal implementation technique would be to
use only *one* function, because this program
does not perform steps to distinguish the elements
of the array f.
Greetings from Bremen,
Daniel Kr?gler
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]