这比您想象的要简单一些...但首先，您使用std::enable_if是错误的：如果你没有提供类型，那么它默认为void，意味着 * 你所有的方法解析为相同的类型 *。打开你的编译器的警告，它会告诉你这类事情。
下面是一种完成测试程序的方法：

// cl /EHsc /W4 /Ox /std:c++17 /wd4100 a.cpp
// clang++ -Wall -Wextra -Werror -pedantic-errors -O3 -std=c++17 -Wno-unused-parameter a.cpp

#include <iostream>
#include <type_traits>

enum image_format {R, G, B, RG, GB, RB, RGB}; // <--- Image format enumeration.

template<int Dimensions, image_format Format>
struct image
{
  image(int size_x, int size_y, char * bytes);

private:
  // Here is the common code for the image<2,R|G|B> constructor to use.
  void image2R(int size_x, int size_y, char * bytes)
  {
    std::cout << "R or G or B\n";
  }

  // (Repeat for image<2,RG|RB|GB>)
  // void image2RG(int size_x, int size_y, char * bytes)
  // {
  //   ...
  // }
};

// Here our constructors will simply dispatch to the common code
template<> image<2, R>::image(int size_x, int size_y, char * bytes) { image2R(size_x, size_y, bytes); }
template<> image<2, G>::image(int size_x, int size_y, char * bytes) { image2R(size_x, size_y, bytes); }
template<> image<2, B>::image(int size_x, int size_y, char * bytes) { image2R(size_x, size_y, bytes); }
// template <> void image<2, RG>::image2RG(int, int, char *) = delete;
// ...

// (Repeat for image<2, RG>, etc.)

// The RGB method only has one variant, so no need for a common code method.
template<> image<2, RGB>::image(int size_x, int size_y, char * bytes)
{
  std::cout << "RGB\n";
}
template<> void image<2, RGB>::image2R(int, int, char *) = delete;
// template<> void image<2, RGB>::image2R(int, int, char *) = delete;
// ...

int main()
{
  image<2, RGB> imgRGB(10, 10, nullptr);
  image<2, G>   imgG  (54, -7, nullptr);
  
//  image<3, RGB> fooey (11, 11, nullptr);  // link error: unresolved external symbol
//  image<2, RG>  quuxl (17, 17, nullptr);  // link error: unresolved external symbol

//  imgRGB.image2R(9,8,nullptr);  // attempting to use a deleted function
//  (If you do uncomment the above line, make sure to
//   comment out the "private:" in the class definition above)

  std::cout << "Hello world!\n";
}

这是因为：

• 我们不会为不需要的模板组合定义构造函数，因此您的用户无法示例化它们。
• 我们将公共构造代码放入一个私有的“helper”函数中，并从适当的构造函数分派给它。为每个有效的公共性编写一个构造函数helper。
• 我们= delete不属于给定模板组合的公共帮助函数，这样它们就不是该类的一部分。

这不是实现目标的唯一方法。还有其他方法。就我个人而言，我不确定你的类设计是我能接受的......但我不知道你的需求，也不知道你对它们有多大的控制力。
对于其他阅读，您可能想在谷歌上搜索“SFINAE”和“C++标记调度”。

不能仅在定义中使用SFINAE。声明签名和定义签名应匹配。由于默认参数不是签名的一部分，请使用

template <typename T, typename = std::enable_if_t<cond<T>>>

使用

template <typename T, std::enable_if_t<cond<T>, int> = 0>

在C++17中，if constexpr可能会有所帮助：

template<image_format format> // <--- Partial template specialization used here
class image<2, format>        // to define image class for 2D images only.
{
private:
    /* Class data here */
public:
    image(int size_x, int size_y, char * bytes)
    {
        if constexpr (format == image_format::R
                    || format == image_format::G
                    || format == image_format::B) {
            // ...
        } else if constexpr (format == image_format::RG) {
            // ...
        } // ...
    }
};

C++20中SFINAE的替代方法是使用requires进行约束：

template<image_format format> // <--- Partial template specialization used here
class image<2, format>        // to define image class for 2D images only.
                              // Note that requires might be also used to avoid specialization
{
private:
    /* Class data here */
public:
    image(int size_x, int size_y, char* bytes)
    requires(format == image_format::R
          || format == image_format::G
          || format == image_format::B)
    {
        // ...
    }
    image(int size_x, int size_y, char* bytes)
    requires(format == image_format::RG
          || format == image_format::GB
          || format == image_format::RB)
    {
        // ...
    }

    // ...
}