C++: Template Specialization causes different result in Debug / Release

Question

In the following code, I create a Builder template, and provide a default implementation to return nothing. I then specialize the template with int, to return a value 37.

When I compile with -O0, the code prints 37, which is the expected result. But when I compile using -O3, the code prints 0.

The platform is Ubuntu 20.04, with GCC 9.3.0

Can anyone helps me understand the behavior?

builder.h

class Builder {
        public:
                template<typename C>
                static C build() {
                        return 0;
                }
};

builder.cc

#include "builder.h"

template<>
int Builder::build<int>() {
        return 37;
}

main.cc

#include "builder.h"
#include <iostream>

int main() {
        std::cout << Builder::build<int>() << '
';
}

makefile

CXX_FLAG = -O0 -g
all:
        g++ $(CXX_FLAG) builder.cc -c -o builder.o
        g++ $(CXX_FLAG) main.cc builder.o -o main
clean:
        rm *.o
        rm main

question from:https://stackoverflow.com/questions/65876360/c-template-specialization-causes-different-result-in-debug-release

Answer 1

You should add a forward declaration for build<int>() to builder.h, like so:

template<>
int Builder::build<int>();

Otherwise, while compiling main.cc, the compiler sees only the generic template, and is allowed to inline an instance of the generic build() function. If you add the forward declaration, the compiler knows you provided a specialization elsewhere, and will not inline it.

With -O3, the compiler tries to inline, with -O0 it will not inline anything, hence the difference.

Your code actually violates the "One Definition Rule": it will create two definitions for Builder::build<int>(), but they are not the same. The standard says the result is undefined, but no diagnostics are required. That is a bit unfortunate in this case, as it would have been helpful if a warning or error message was produced.