Question

我不确定在这里使用什么术语，但这个问题介绍了我的问题： Language with apps hungarian support?

我认为使用C ++ 11中新的用户定义的文字，类似于上面链接的海报调用＆＃34;强类型定义＆＃34;将会介绍，但似乎并非如此。我希望我错了，这很方便。 :)

具体来说，我想要这个：

typedef int column;
typedef int row;

void myColumnFunc(column)
{
}

main()
{
    column myColumn = 0;
    row myRow = 0;
    int myInt = 0;

    myColumnFunc(myColumn); // OK
    myColumnFunc(myRow); // I want a compiler error here
    myColumnFunc(myInt); // I want a compiler error here

}

如果有特定于编译器的选项，请提及它，但我在跨平台工作，因此它不是真正的解决方案。

我可以想到几个变通办法（类，枚举类），但是一个强大的typedef＆＃34;会是理想的。

我的问题是：有没有办法强制执行我忽略的事情。如果没有，我会对惯用的解决方法感兴趣，如果有的话。如果没有，我可能会使用枚举类。

Answer 1

有两种选择：

boost strong_typedef
使用c ++ 11 strong typedef枚举（请参阅wiki page）

在这两种情况下，您将引入一种新类型，如果您传递错误的＆＃34;值＆＃34;编译器会抱怨这个功能。

强类型定义枚举的示例：

enum class column
{
    ONE = 1,
    TWO,
    FIVE
};

typedef int row;

void myColumnFunc(column)
{
}

int main()
{
    column myColumn = column::TWO;
    row myRow = 0;
    int myInt = 0;

    myColumnFunc(myColumn); // OK
    //myColumnFunc(myRow);                                   // I want a compiler error here
    //myColumnFunc(myInt);                                   // I want a compiler error here
}

Answer 2

如果您不喜欢boost提供的选项（也许boost units比已经提到的boost strong typedef更合适），那么滚动自己的基础知识就像下面这样：

#include <iostream>

template<typename tag, typename base = int>
class tagged {
public:
    explicit tagged(const base& val) : val_(val) {}
    explicit operator base() const { return val_; }
private:
    base val_;
};

struct column_tag{};
struct row_tag{};
typedef tagged<column_tag> column;
typedef tagged<row_tag> row;

template<typename tag, typename base>
tagged<tag, base> operator+(const tagged<tag, base>& a, const tagged<tag, base>& b) {
    return tagged<tag, base>{static_cast<base>(a) + static_cast<base>(b)};
}

void myColumnFunc(column){}

int main()
{
    column myColumn{2};
    row    myRow{1};
    myColumnFunc(myColumn);
//    myColumnFunc(myRow); // error: could not convert ‘myRow’ from ‘row {aka tagged<row_tag>}’ to ‘column {aka tagged<column_tag>}’
    std::cout << static_cast<int>(column{2} + column{3}) << std::endl;
//    std::cout << static_cast<int>(column{2} + row{2}) << std::endl; // error: no match for ‘operator+’ (operand types are ‘column {aka tagged<column_tag>}’ and ‘row {aka tagged<row_tag>}’)
}

强大的typedef /编译器强制应用程序匈牙利语C ++

2 个答案: