条件编译代码记录

#include <iostream>

// 基类模板
template<typename T>
class Base {
public:
	void func() {
		std::cout << "Base function" << std::endl;
	}
};

// 特化的子类
template<typename T>
class Derived : public Base<T> {
public:
	void func() {
		std::cout << "Derived function" << std::endl;
	}
};

// 完全特化的子类
template<>
class Derived<int> : public Base<int> {
public:
	void func() {
		std::cout << "Specialized Derived<int> function" << std::endl;
	}
};

int main() {
	Derived<double> d1;  // 这个对象使用的是 Derived<double>
	d1.func();           // 输出: "Derived function"

	Derived<int> d2;     // 这个对象使用的是完全特化的 Derived<int>
	d2.func();           // 输出: "Specialized Derived<int> function"

	Base<double> b;      // 基类实例
	b.func();            // 输出: "Base function"

	return 0;
}

std::enable_if_t<std::is_same_v<U, Dim3>, Ptr> 如何使用？

#include <iostream>
#include <type_traits>

// 定义不同的MyType子类型
class MyTypeA {
public:
	void process() {
		std::cout << "Processing MyTypeA" << std::endl;
	}
};

class MyTypeB {
public:
	void process() {
		std::cout << "Processing MyTypeB" << std::endl;
	}
};

class MyTypeC {
public:
	void process() {
		std::cout << "Processing MyTypeC" << std::endl;
	}
};

// 函数模板，用于处理MyTypeA
template <typename T>
typename std::enable_if_t<std::is_same_v<T, MyTypeA>, void> process(T& obj) {
	obj.process(); // 处理MyTypeA
}

// 函数模板，用于处理MyTypeB
template <typename T>
typename std::enable_if_t<std::is_same_v<T, MyTypeB>, void> process(T& obj) {
	obj.process(); // 处理MyTypeB
}

// 函数模板，用于处理MyTypeC
template <typename T>
typename std::enable_if_t<std::is_same_v<T, MyTypeC>, void> process(T& obj) {
	obj.process(); // 处理MyTypeC
}

template <typename U>
void templateFunction(U& obj) {
	process(obj); // 调用具体的process函数
}

int main() {
	MyTypeA myObjA;
	MyTypeB myObjB;
	MyTypeC myObjC;

	templateFunction(myObjA);  // 输出: Processing MyTypeA
	templateFunction(myObjB);  // 输出: Processing MyTypeB
	templateFunction(myObjC);  // 输出: Processing MyTypeC

	// 如果你尝试以下代码，将导致编译错误：
	// std::string str; // 这里是一个不支持的类型
	// templateFunction(str); // 编译错误，因为没有对应的process函数处理std::string
}

if constexpr (std::is_same_v< >和std::enable_if_t<std::is_same_v>有什么区别

template<typename T, typename U>；

std::enable_if_t<std::is_same_v<U, Dim3>, void> 代码里可以对T和U多条件判断吗？

对模板参数 T 和 U 进行多条件判断。在 C++ 中，可以通过使用 std::enable_if、constexpr 表达式以及组合多种类型特性（比如 std::is_integral、std::is_floating_point 等）来实现复杂的条件逻辑。

以下是几种常见的方法来对 T 和 U 进行多条件判断：

1. 使用 std::enable_if

可以将多个条件组合在一起，例如使用逻辑运算符 && 或 ||。以下是示例代码：

#include <type_traits>

template<typename T, typename U>
class Shaper {
public:
    // 当 T 是整型且 U 是 Dim3 时，启用 reshape 函数
    template<typename = std::enable_if_t<std::is_integral<T>::value && std::is_same_v<U, Dim3>>>
    void reshape(float* data, ...) {
        // 实现
    }

    // 另外一个 reshape 函数，当 U 是其他类型时（例如，浮点型）
    template<typename = std::enable_if_t<std::is_floating_point<U>::value>>
    void reshape(float* data, ...) {
        // 实现其他逻辑
    }
};

2. 通过类型萃取和其他类型特性进行组合

您可以还可以使用组合类型特性进行更复杂的判断：

#include <type_traits>

template<typename T, typename U>
class Shaper {
public:
    // 当 T 是整型且 U 是 Dim3 或者 U 是某个其他类型时启用 reshape 函数
    template<typename = std::enable_if_t<std::is_integral<T>::value && (std::is_same_v<U, Dim3> || std::is_floating_point<U>::value)>>
    void reshape(float* data, ...) {
        // 实现
    }
};

3. 组合多个 enable_if 条件

您也可以在模板上直接组合多个 enable_if 条件：

#include <type_traits>

template<typename T, typename U>
class Shaper {
public:
    template<typename = std::enable_if_t<std::is_integral<T>::value && std::is_same_v<U, Dim3> && SomeOtherCondition<U>::value>>
    void reshape(float* data, ...) {
        // 实现
    }
};

has_value_member

// 模板函数，只有在T没有value成员时才会启用

template<typename T>

typename std::enable_if<!has_value_member<T>::value>::type

#include <iostream>
#include <type_traits>

// 用于检测类型T是否有一个名为 value_type 的类型成员
template <typename T, typename = void>
struct has_value_type : std::false_type {};

// 特化 if 提供实现
template <typename T>
struct has_value_type<T, std::void_t<typename T::value_type>> : std::true_type {};

// 一个示例结构体，具备 value_type
struct StructWithValue {
	using value_type = int; // 定义类型成员
	value_type value; // 实例成员
};

// 一个不具备 value_type 的结构体
struct StructWithoutValue {
	double value; // 没有定义类型成员value_type
};

template<typename T, typename Enable = void>
class Widget;

// 特化 Widget，当T有value_type时
template<typename T>
class Widget<T, typename std::enable_if<has_value_type<T>::value>::type> {
public:
	void printIfHasValue() {
		std::cout << "T has value type member." << std::endl;
	}
};

// 特化 Widget，当T没有value_type时
template<typename T>
class Widget<T, typename std::enable_if<!has_value_type<T>::value>::type> {
public:
	void print() {
		std::cout << "This type doesn't have a value_type member." << std::endl;
	}
};

int main() {
	Widget<StructWithValue> wa;
	wa.printIfHasValue(); // 正确: T是有值类型成员的结构体
	
	Widget<StructWithoutValue> wb;
	wb.print(); // 输出: This type doesn't have a value_type member.

	return 0;
}

多模版参数处理

template <typename T, typename U,bool DeviceType>，有时需要template <typename T, typename U, typename D,bool DeviceType>,怎么设计呢？

1特化：

#include <iostream>
#include <type_traits>

// 主模板，使用 std::conditional 选取 D 类型
template <typename T, typename U, bool DeviceType, typename D = void>
class MyTemplate;

// 特化，处理只有两个类型和布尔值的情况
template <typename T, typename U, bool DeviceType>
class MyTemplate<T, U, DeviceType, void> {
public:
	void print() {
		std::cout << "Using template with two types (T, U) and a bool." << std::endl;
	}
};

// 特化，处理带有第三个类型 D 的情况
template <typename T, typename U, typename D, bool DeviceType>
class MyTemplate<T, U, DeviceType, D> {
public:
	void print() {
		std::cout << "Using template with two types (T, U), an additional type (D), and a bool." << std::endl;
	}
};

int main() {
	MyTemplate<int, double, true> instance1;  // 使用两个类型的模板
	instance1.print();

	MyTemplate<int, double, true, char> instance2;  // 使用三个类型的模板
	instance2.print();

	return 0;
}

特化二：

#include <iostream>
#include <type_traits>

// 基本模板，两个类型和一个布尔值
template <typename T, typename U, typename D = void, bool DeviceType = false>
class MyTemplate {
public:
	void print() {
		std::cout << "Using template with T, U, D (defaulted), and DeviceType." << std::endl;
	}
};

// 特化版本，当 D 不是 void 时
template <typename T, typename U, typename D>
class MyTemplate<T, U, D, true> {
public:
	void print() {
		std::cout << "Using template with T, U, and a third type D, with DeviceType set to true." << std::endl;
	}
};

int main() {
	MyTemplate<int, double> myInstance1; // 使用默认的D为void，DeviceType为false
	myInstance1.print();

	MyTemplate<int, double, char, true> myInstance2; // 指定了D和DeviceType
	myInstance2.print();

	return 0;
}

当您希望根据条件选择不同数量的模板参数时，一种常见的方法是使用递归模板或辅助结构如类型特征来处理这种情况。然而，对于您提出的特定需求（即有条件地在模板中使用额外的类型参数），一种实际的方法是使用模板偏特化和默认模板参数联合使用，但不能通过改变参数数量的方式来实现。

下面我们将使用默认模板参数和SFINAE（Substitution Failure Is Not An Error）技巧来提供一个解决方案。

方案说明

一个更实用的方法是设计一个包裹类型或使用一个已经存在的如 std::enable_if，std::conditional 或自定义类型特征来根据条件启用或禁用第三个类型参数。但对于直接添加或移除模板参数，在C++模板中这是不可能实现的。取而代之的是，我们可以按需使用第三个类型参数，让它在某些情况下为 void 类型或其他不影响的类型。

改进后的例子

考虑到上述限制，如果我们要实现一个这样的结构，我们必须以稍微不同的方式思考。以下是一种使用 std::conditional 来选择第三个参数是一个有效类型还是 void 的方法。此方法并不完美，但展示了如何基于给定的布尔值 DeviceType 来静态选择类型。

#include <iostream>
#include <type_traits>

template <typename T, typename U, bool DeviceType, typename D = void>
class MyTemplate {
public:
    using ConditionallyEnabledType = typename std::conditional<DeviceType, D, void>::type;

    void print() {
        if constexpr (std::is_same<ConditionallyEnabledType, void>::value) {
            std::cout << "Template with T, U, and DeviceType, D is void." << std::endl;
        } else {
            std::cout << "Template with T, U, DeviceType and D as an additional type." << std::endl;
        }
    }
};

int main() {
    MyTemplate<int, double, false> myInstance1; // D will be considered void
    myInstance1.print();

    MyTemplate<int, double, true, char> myInstance2; // D will be enabled as 'char'
    myInstance2.print();

    return 0;
}

为什么不完美？

你的代码使用了模板的SFINAE（Substitution Failure Is Not An Error）技术，来根据编译时的条件（是否指定了类型参数D）来选择性地启用某个类型。这个设计对于特定模板类的某些条件来说是有效的，但有几个潜在的问题和局限性需要注意：

1. 模板参数默认值不完整 ：你的模板参数D默认值是void，这会导致在某些情况下不完全匹配预期行为。如果DeviceType为false，你默认没有为D提供任何类型信息，这使得编译器难以解析你的模板，因为它无法确定哪个类型是默认的。虽然你的代码可能能够编译成功，但这种不明确性可能会导致混淆或误解。通常更好的做法是明确指定所有模板参数的类型，即使它们有默认值。

2. 模板参数不完整：你的模板类依赖于一个布尔值来决定是否启用某个类型，这种设计对于特定的用例可能是有效的，但它限制了模板的灵活性。如果模板设计用于更广泛的用途，可能需要更复杂的逻辑来根据多个条件启用或禁用类型。此外，使用布尔值作为模板参数通常不是一个好的做法，因为它增加了代码与特定编译逻辑的耦合性。更常见的是使用条件模板或别名来达成同样的效果。

针对这些问题，一个改进的方式是重新定义模板以考虑所有的参数依赖和上下文，比如：

template <typename T, typename U> // 无需显式的DeviceType和D类型参数，因为这些可以作为函数内部逻辑的一部分处理
class MyTemplate {
public:
    template <typename D = void> // 使用默认模板参数来处理可能的额外类型D
    void print() { // 此函数将根据是否提供了额外的类型D来处理不同的逻辑
        if constexpr (std::is_void<D>::value) { // 使用std::is_void而不是直接比较来检查类型是否为void
            std::cout << "Template with T and U." << std::endl; // 根据是否提供了额外的类型输出不同的消息
        } else {
            std::cout << "Template with T, U, and additional type D." << std::endl;
        }
    }
};
```在这个修改中，`DeviceType`是隐藏在逻辑内部而不作为一个独立的模板参数出现的。我们通过将布尔值与`void`进行比较（如检查类型是否为void），或者在编译器基于上下文的情境中创建内部函数而不是完整的独立参数集来解决前面的问题。然而这种方式虽然避免了对非用户直接参与的中间类型的直接引用，但它仍然依赖于特定的编译逻辑来根据条件启用或禁用某些功能。在设计复杂的模板时，需要权衡灵活性和清晰度之间的权衡。

#include <iostream>
#include <type_traits>

struct Color {};

// 假设 Linear 是某种类型
struct Gray {};

// 模板类定义
template <typename T, typename U>
class MyTemplate {
public:
	template <typename D = Gray> //默认
	void print() {
		if constexpr (std::is_same_v<D, Color>) {
			std::cout << "Template with T and U." << std::endl;
		}
		else {
			std::cout << "Template with T, U, and additional type D." << std::endl;
		}
	}
};

int main() {
	// 使用基本模板实例化，T = int, U = float
	MyTemplate<int, float> myTemplate1;
	myTemplate1.print();  // 输出：Template with T, U, and additional type D.

	// 使用额外的类型D，这里我们指定为Linear
	myTemplate1.print<Color>();  // 输出：Template with T and U.

	// 另一个实例化，使用不同的类型
	MyTemplate<double, char> myTemplate2;
	myTemplate2.print();  // 输出：Template with T, U, and additional type D.

	// 继续使用额外的类型
	myTemplate2.print<Gray>();  // 输出：Template with T and U.

	return 0;
}

上面程序只判断一层模版，如果判断多层模版呢？

#include <iostream>
#include <type_traits>

struct dim3
{

};

struct dim2
{

};

struct Color {};

// 假设 Linear 是某种类型
struct Gray {};

// 模板类定义
template <typename T, typename U>
class MyTemplate {
public:
	template <typename D = Gray> //默认
	void print() {
		if constexpr (std::is_same_v<D, Color> && std::is_same_v<U, dim3>) {
			std::cout << "Template with T and U." << std::endl;
		}
		else {
			std::cout << "Template with T, U, and additional type D." << std::endl;
		}
	}
};

int main() {
	// 使用基本模板实例化，T = int, U = float
	MyTemplate<int, dim3> myTemplate1;
	myTemplate1.print();  // 输出：Template with T, U, and additional type D.

	// 使用额外的类型D，这里我们指定为Linear
	myTemplate1.print<Color>();  // 输出：Template with T and U.

	// 另一个实例化，使用不同的类型
	MyTemplate<double, char> myTemplate2;
	myTemplate2.print();  // 输出：Template with T, U, and additional type D.

	// 继续使用额外的类型
	myTemplate2.print<Gray>();  // 输出：Template with T and U.


	MyTemplate<double, dim3> myTemplate3;
	myTemplate3.print<Color>();  // 输出：Template with T, U, and additional type D.

	return 0;
}

使用变参模板

另一种方式是使用变参模板。这种方法允许更灵活的参数数量和类型。下面的示例展示了如何设计可以接受不同参数数量的模板：

#include <iostream>
#include <type_traits>

// 基本模板定义
template <typename T, typename U, bool DeviceType, bool HasExtraType = false, typename... Args>
class MyTemplate;

// 特化版本，仅基于两种类型和布尔值
template <typename T, typename U, bool DeviceType>
class MyTemplate<T, U, DeviceType, false> {
public:
	void print() {
		std::cout << "Using template with two types and a bool." << std::endl;
	}
};

// 特化版本，带有额外类型参数
template <typename T, typename U, bool DeviceType, typename... Args>
class MyTemplate<T, U, DeviceType, true, Args...> {
public:
	void print() {
		std::cout << "Using template with two types, one additional type, and a bool." << std::endl;
	}
};

int main() {
	MyTemplate<int, double, true> myInstance1;
	myInstance1.print(); // 将调用第一个特化版本

	MyTemplate<int, double, true, true, char> myInstance2; // 需要明确指定有额外类型
	myInstance2.print(); // 将调用第二个特化版本

	return 0;
}

功能：指定类型才能调用成员函数

typename std::enable_if<std::is_same<D, Dim2>::value>::type 是 C++ 中一种常用的 SFINAE（Substitution Failure Is Not An Error）技术，主要用于条件性地启用或禁用模板函数。让我们逐步解析这个表达式。

逐步解析

1. std::is_same<D, Dim2>::value：

   • std::is_same 是 C++ 标准库中的一个类型特性，它用于检查两个类型是否相同。
   • std::is_same<D, Dim2>::value 将返回一个布尔值：如果 D 是 Dim2 类型，则为 true；否则为 false。

2. std::enable_if：

   • std::enable_if 是一个模板类，它的作用是在满足特定条件时定义类型，同时在不满足条件时不定义类型。
   • std::enable_if<Condition, T>::type 的逻辑是：
     • 如果 Condition 为 true，那么 std::enable_if 将定义一个类型 T。
     • 如果 Condition 为 false，则不定义这个类型，并导致 SFINAE（替代失败不是错误）。

3. typename std::enable_if<std::is_same<D, Dim2>::value>::type：

   • 如果 std::is_same<D, Dim2>::value 为 true，enable_if 会定义一个类型，并通过 typename 关键字进行引用。通常，这个类型会被设为 void（默认）。
   • 如果条件不成立（即 D 不是 Dim2），那么这个类型不会被定义，导致这一重载函数在不满足的情况下被排除。

用法示例

在模板函数中使用这个技术的目的是：

• 条件编译：使得某个特定的函数重载只有在某些情况下可用。

  #include <iostream>
  #include <type_traits>

  struct Dim2 {};
  struct Dim3 {};

  class Resizer {
  public:
  // 当 D 为 Dim2 时有效
  template<typename D>
  typename std::enable_if<std::is_same<D, Dim2>::value>::type
  resize() {
  std::cout << "Resizing for Dim2!" << std::endl;
  }

    // 当 D 为 Dim3 时有效
    template<typename D>
    typename std::enable_if<std::is_same<D, Dim3>::value>::type
    resize() {
        std::cout << "Resizing for Dim3!" << std::endl;
    }
  

  };

  int main() {
  Resizer resizer;
  resizer.resize<Dim2>(); // 输出: Resizing for Dim2!
  resizer.resize<Dim3>(); // 输出: Resizing for Dim3!
  // resizer.resize<int>(); // 如果取消注释，这将导致编译错误
  return 0;
  }

总结

通过 std::enable_if，可以实现特定条件下的函数重载功能。在这个例子中，resize 函数的版本只有在模板参数 D 为 Dim2 或 Dim3 时才是可用的。其他类型（如 int）将导致编译错误，而不会使程序崩溃或其他运行时错误，有效地增强了类型安全性。