C++ 在C++；

我正在为我的结构使用模板，如：

#pragma pack(push, 1)
template <typename T>
struct S
{
   T t;

   inline void Set(const T& val) { t = val; }
}
#pragma pack(pop)

#pragma包（推送，1）
模板
结构
{
T；
内联空集（常数T&val）{T=val；}
}
#布拉格语包（流行语）

T可以是float、int、short或char[10]、char[1]或char[2]（最好是任意长度）

虽然上面的方法对于整型似乎很有效，但我在实现char[n]部分时遇到了困难：

我需要使用strncpy或memcpy而不是赋值运算符

使用上述方法，编译器会抱怨签名（constchar[2]&val）和我通过s.Set（“T”）调用它

具有整型和字符类型的S之间的接口必须与调用它们的泛型代码相同（并且不关心它们是什么类型）

在

char[10]

等情况下，您可以为

T

定义模板专门化。这样做时是否还存在任何问题？但正如Mat已经指出的，使用字符串是一种值得考虑的方法

#include <iostream>

#pragma pack(push, 1)
template <typename T>
struct S
{
   T t;

   inline void Set(const T& val) { std::cout << "general\n"; }
};

template <int len>
struct S<char[len]>
{
   char t[len];

   inline void Set(const std::string& val) { std::cout << "specialization\n"; }
};
#pragma pack(pop)

int main() {

    S<int> a;
    a.Set(10);

    S<char[20]> b;
    b.Set("turkey!");

    return 0;
}

#包括
#pragma包（推送，1）
模板
结构
{
T；
内联void Set（const T&val）{std:：cout在
char[10]
等情况下，您可以为
T
定义模板专门化。这样做时是否还存在任何问题？但正如Mat已经指出的，使用字符串是一种值得考虑的方法

#include <iostream>

#pragma pack(push, 1)
template <typename T>
struct S
{
   T t;

   inline void Set(const T& val) { std::cout << "general\n"; }
};

template <int len>
struct S<char[len]>
{
   char t[len];

   inline void Set(const std::string& val) { std::cout << "specialization\n"; }
};
#pragma pack(pop)

int main() {

    S<int> a;
    a.Set(10);

    S<char[20]> b;
    b.Set("turkey!");

    return 0;
}

#包括
#pragma包（推送，1）
模板
结构
{
T；
内联void集（const T&val）{std:：cout对我来说很好：

#pragma包（推送，1）
模板
结构
{
T；
内联空集（常数T&val）{}
};
#布拉格语包（流行语）
int main（）{
typedef char（carray）[10]；//你有这样一行吗？
S-lhs；
carray rhs=“你好”；
左S.组（右S）；
返回0；
}

您的问题很可能是由于使用了不正确的数组类型造成的。有关正确的typedef的示例，请参阅我的代码

编辑：
我刚刚意识到，如果您已经有了
std:：string
或任何类型的动态数组，那么调用
Set
会很痛苦。请进行模板专门化。
对我来说很好：

#pragma包（推送，1）
模板
结构
{
T；
内联空集（常数T&val）{}
};
#布拉格语包（流行语）
int main（）{
typedef char（carray）[10]；//你有这样一行吗？
S-lhs；
carray rhs=“你好”；
左S.组（右S）；
返回0；
}

您的问题很可能是由于使用了不正确的数组类型造成的。有关正确的typedef的示例，请参阅我的代码

编辑：
我刚刚意识到，如果您已经有了
std:：string
或任何类型的动态数组，那么调用
Set
会很痛苦。请执行模板专门化。
好吧，部分专门化可能会达到以下目的：

template <typename T> struct S
{
  T x;
  void set(const T & y) { x = y; }
};

template <typename T, unsigned int N> struct S<T[N]>
{
  T x[N];
  void set(const T (&y)[N]) { std::copy(y, y + N, x); }
};

模板结构
{
tx；
空集（常数T&y）{x=y；}
};
模板结构
{
tx[N]；
空集（常数T（&y）[N]）{std:：copy（y，y+N，x）；}
};

用法：

S<char[10]> b;
char c[10] = "Hello";
b.set(c);

sb；
字符c[10]=“你好”；
b、 set（c）；
好吧，部分专门化可能会起到以下作用：

template <typename T> struct S
{
  T x;
  void set(const T & y) { x = y; }
};

template <typename T, unsigned int N> struct S<T[N]>
{
  T x[N];
  void set(const T (&y)[N]) { std::copy(y, y + N, x); }
};

模板结构
{
tx；
空集（常数T&y）{x=y；}
};
模板结构
{
tx[N]；
空集（常数T（&y）[N]）{std:：copy（y，y+N，x）；}
};

用法：

S<char[10]> b;
char c[10] = "Hello";
b.set(c);

sb；
字符c[10]=“你好”；
b、 set（c）；
Why
char[]
s而不是
std:：string
s？您不会有这些问题。@Mat它是在打包结构的上下文中使用的，直接放在线路上，std:：string很遗憾不能用于此目的。您仍然可以为
Set
方法使用
std:：string
。@Mat不确定我是否在使用它。参数类型In Set方法必须与typename T相同？@Mat:这不会花很短时间。克里斯特柯克：是的。看我的答案，你的代码很好。为什么
char[]
s而不是
std:：string
s？您不会有这些问题。@Mat它是在打包结构的上下文中使用的，直接放在线路上，std:：string很遗憾不能用于此目的。您仍然可以为
Set
方法使用
std:：string
。@Mat不确定我是否在使用它。参数类型In set方法需要与类型名T @ @ Mat相同：这不会太短。Christkirk：是的，它确实是。看看我的答案，你的代码很好。我想我的问题是C++模板语法比概念多。你能提供一个这样的专门化的例子吗？@克里斯科克：专业化实际上归结为一次编写班级。r整数类型，一次用于字符数组。这是可以避免的，但也可以使事情变得更简单。@MooingDuck是否也可以在方法签名中为所有类型char[n]的专门化设置std:：string？我认为从最终用户的角度来看，这会更方便一些。@chriskirk：当然。除了完全限定的类名之外，没有任何东西说专门化必须与泛型有任何共同之处。@MooingDuck你能提供一个例子吗？我确实很感兴趣=）我想我的问题是H+C++模板语法比概念更重要。你能提供这样一个专门化的例子吗？@克里斯科克：专业化实际上归结为一次编写类为整型，一次用于char数组。这是可以避免的，但也可以使事情变得更容易。@ MooingDuck也可能在方法SIG中有STD::string。char[n]类型的所有专门化的性质？我认为从最终用户的角度来看，这会更方便一些。@chriskirk：当然。除了完全限定的类名之外，没有任何东西说专门化必须与泛型有任何共同之处。@MooingDuck请您提供一个这样的例子好吗？我确实非常感兴趣=）有趣的方法。我没有像你描述的那样使用typedef。你确定这是你认为的那样吗？@KerrekSB：你犯的错误比我少，但是