Especialización de Plantillas C++ con Valor Constante

Necesitas poner la especialización en el lugar correcto:

template <typename A> class Example<A,2>

Si quieres crear una subclase:

template <typename A> class ExampleSpecialization : public Example<A,2>

El comportamiento para especializarse en typedefs es similar al comportamiento para especializarse en un parámetro entero.

Si la memoria no me falla, debería ser más como:

template <typename A, size_t B> class Example
{
    public:
        Example() { };

        A value[B];
};

template <typename A> class Example<A, 2>
{
    public:
        Example(A b1, A b2) { value[0] = b1; value[1] = b2; };
};

No creo que esto sea bastante permisible tal cual though no hay nada definiendo los tipos de b1 y/o b2 en la versión especializada.

Editar [basado en una pregunta editada]: Sí, una especialización de plantilla produce un nuevo tipo que no está realmente relacionado con la base desde la que se especializa. In particular, the two do not share any of the implementation. Usted no puede (especializando una plantilla de clase) producir un tipo único que utiliza uno de dos ctors diferentes, dependiendo del valor de un parámetro que no es de tipo.

Puedes probar algo como esto:

template<size_t s>
struct SizeTToType { static const size_t value = s; };

template<bool> struct StaticAssertStruct;
template<> struct StaticAssertStruct<true> {};
#define STATIC_ASSERT(val, msg) { StaticAssertStruct<((val) != 0)> ERROR_##msg; (void)ERROR_##msg;}

template <typename A, size_t B> 
class Example
{
    public:
        Example() { };
        Example(A b1){ value[0] = b1; }
        Example(A b1, A b2) { 
                STATIC_ASSERT(B >= 2, B_must_me_ge_2); 
                value[0] = b1; value[1] = b2;
        } 
        A foo() { return in_foo(SizeTToType<B>()); }
    protected:
        template<size_t C>
        A in_foo(SizeTToType<C>) {
                cout << "univ" << endl;
                A r;
                for (size_t i = 0; i < B; ++i)
                r += value[i];
                return r;
        }
        A in_foo(SizeTToType<2>){
                cout << "spec" << endl;
                return value[0] + value[1];
        }
        A value[B];
};

Ejemplo de Trabajo en http://www.ideone.com/wDcL7

En las plantillas, si no está utilizando el método, no existirá en el código compilado, por lo que esta solución no debería hacer que el ejecutable sea más grande debido a los ctors que no puede usar con alguna clase especializada (por ejemplo, Example<int, 1> no debería tener Example(A b1, A b2) ctor).

Si su objetivo es solo tener que anular unos pocos métodos/constructores en sus especializaciones, entonces tal vez considere una clase base genérica para mantener la implementación común para todas las plantillas Example para que no tenga que reescribirla en cada especialización que se le ocurra.

Por ejemplo:

template < typename A, size_t B >
class ExampleGeneric {
public:

  // generic implementation of foo inherited by all Example<A,B> classes
  void foo() {
    A r;

    for (size_t i = 0; i < B; ++i)
      r += value[i];

    return r;
    }

  // generic implementation of bar inherited by all Example<A,B> classes
  void bar() {
    A r;

    for (size_t i = 0; i < B; ++i)
      r *= value[i];

    return r;
    }

  A values[B];
  };

template < typename A, size_t B >
class Example : public ExampleGeneric<A,B> {
public:
  //default to generic implementation in the general case by not overriding anything
  };

//*** specialization for 2
template < typename A >
class Example<A,2> : public ExampleGeneric<A,2>{
public:

  // has to be provided if you still want default construction
  Example() {
    }

  //extra constructor for 2 parameters
  Example( A a1, A a2 ) {
    values[0] = a1;
    values[1] = a2;
    }

  // specialization of foo
  void foo() {
    return values[0] + values[1];
    }

  // don't override bar to keep generic version
  };

#include <iostream>

using namespace std;


template<typename _T, size_t S>
class myclass {
    _T elem[S];
public:
    myclass() {
        for (int i = 0; i < S; i++) {
            elem[i] = i;
        }
    }
    void Print() {
        for (int i = 0; i < S; i++) {
            cout << "elem[" << i << "] = " << elem[i] << endl;
        }
    }
};


int main(int argc, char **argv)
{
    myclass < int, 10 > nums;
    nums.Print();
    myclass < int, 22 > nums1;
    nums1.Print();
}

Que funcionó en mi máquina linux con

G++ (GCC) 4.1.2 20080704 (Red Hat 4.1.2-48) Copyright (C)2006 Free Software Foundation, Inc. Esto es software libre; vea la fuente para condiciones de copia. NO hay garantía; ni siquiera para COMERCIABILIDAD o IDONEIDAD PARA UN PROPÓSITO PARTICULAR.