如何为内置类型（如C+中的整数）添加成员函数+； 我用C++实现了一些东西，我有一个类型索引集群，它包括两个成员：一个是整数，另一个是结构，像这样： typedef int IndexA_t; struct IndexB_t { ... };

这里有一个要求，我想为这两种类型添加一个公共函数（假设，将其命名为fun1（）），因为我想在一个模板函数中传递它们，该模板函数将调用fun1（），对于IndexB\u t实现这一点很容易，但对于IndexA\u t，这让我感到困惑，如何为整数（内置）类型引入函数成员？我必须实现一个模拟int类型的类吗？它确实需要很多不必要的工作（许多操作员…），还有其他方法吗

---

非常感谢您的帮助，谢谢。

实现一个类似于

int

但可以扩展的类型并不难

#include <iostream>

class Int
{
  int m_i;
public:
  Int(int i) : m_i(i) {};
  operator int&() { return m_i; }
  operator int() const { return m_i; }
};

void func(int) {}

int main()
{
  // copy-assignment from int
  Int i = 2;
  i = 4+15;

  // Binding reference
  int& x = i;
  x = 2;

  // Implicit conversion in expression
  std::cout << i + 2 << '\n';

  // Implicit conversion in parameter
  func(i);
}

#包括
类Int
{
国际货币基金组织；
公众：
Int（Int i）：m_i（i）{}；
运算符int&（{return m_i；}
运算符int（）常量{return m_i；}
};
void func（int）{}
int main（）
{
//从int复制赋值
Int i=2；
i=4+15；
//绑定引用
int&x=i；
x=2；
//表达式中的隐式转换
std:：cout您可以按照cornstalks的建议执行，并使用
std:：begin
和
std:：end
所使用的相同技术。它为定义
begin
/
end
成员函数的对象提供重载，并为其他类型（在这种情况下为数组）提供重载，以便在上使用该函数

在下面的设计示例中，我们有一个
getval
free函数，它为定义
getval
成员函数的类型提供重载，使用尾部返回类型激活SFINAE。然后对于其他类型，它使用类型特征确保只允许整数类型，而拒绝所有其他类型，同样是using SFINAE通过
启用\u如果

这个例子是精心设计的，只想展示一种技术，你可以使用它来实现你需要的任何功能（问题没有详细说明这是什么，所以我不得不使用许可证）。在下面的情况下，通过向
IndexB\u t
类添加int转换运算符显然更容易实现相同的效果，但这不是重点

#include <iostream>
#include <type_traits>
using namespace std;

/* is_integer type trait */
template<typename T>
using is_integer = is_same<remove_cv_t<T>, int>;

template<typename T>
constexpr bool is_integer_v = is_integer<T>::value;

/* getval function definition */
template<typename T, 
         typename = enable_if_t<is_integer_v<T>>
        >
T getval(T i)
{ return i; }

template<typename T>
auto getval(T& t) -> decltype(t.getval())
{ return t.getval(); }

/* defined types */
typedef int IndexA_t;

class IndexB_t 
{ 
    int x;

    public:
    IndexB_t(int i) : x(i) {}

    int getval() const { return x; }
};

// a test struct with no `getval` member function.
struct NoGetVal {};

// driver function
int main()
{
    int i = 9;
    IndexB_t j = 10;
    IndexA_t k = 11;
    const int l = 12;
    volatile int m = 13;
    const volatile int n = 14;
    float a = 1.1;
    NoGetVal ngv;

    cout << getval(i) << '\n';
    cout << getval(j) << '\n';
    cout << getval(k) << '\n';
    cout << getval(l) << '\n';
    cout << getval(m) << '\n';
    cout << getval(n) << '\n';

    // disallowed as not int
    //cout << getval(a) << '\n';

    // disallowed no `getval` member function
    //cout << getval(ngv) << '\n';
}

#包括
#包括
使用名称空间std；
/*是整数型特征*/
模板
使用is_整数=is_相同；
模板
constexpr bool is_integer_v=is_integer:：value；
/*getval函数定义*/
模板
T getval（T i）
{返回i；}
模板
自动getval（T&T）->decltype（T.getval（））
{返回t.getval（）；}
/*定义类型*/
typedef int IndexA_t；
类索引
{ 
int x；
公众：
IndexB_t（int i）：x（i）{}
int getval（）常量{return x；}
};
//没有'getval'成员函数的测试结构。
结构NoGetVal{}；
//驱动函数
int main（）
{
int i=9；
指数x_t j=10；
指数k=11；
常数int l=12；
挥发性int m=13；
常数volatile int n=14；
浮点数a=1.1；
诺盖特瓦尔ngv；
你不能。但是，你可以使
fun1（）
成为一个独立的函数，它接受它的参数并执行必要的工作。类似于一个独立的函数，它将容器作为参数，然后将委托给该容器上的
。begin（）
（如果可以的话）（例如
std:：vector
），或委托给其他可以返回正确值的对象（例如，像
int[5]
这样的数组，它没有
.begin（）
）。如何通过模板专门化来确定容器是否可以调用.beign（）？是的，这是可能的，但我想知道是否有其他方法，我真的不想维护自定义的int类(