Question

更新

如果有人对诉讼感兴趣，GitHub project is here。尽管效果很好，但我仅将其简化为算术类型。

未来的发展将带来更多。

谢谢大家

原始帖子

是的，我知道this question。请阅读它以获得良好的介绍。这是一个聪明但并非通用的解决方案。

我确实很在意，但我也确实需要一些不可转换的基本类型。这样做会严重限制引入错误的可能性。不仅允许不进行隐式转换的函数调用，而且还适用于变量的创建，赋值，比较等。

我确信这已经尝试过，也许以前已经解决了。我的程序中不得包含此内容：

  // implicit conversions
  // no warnings 
  {
     char character = 127 ;
     bool truth = 0 ;
     size_t size_ = truth ;
     int integer = false ;
     size_ = integer;
     size_ = character ;
  }

在我的VS 2017（最新）中，即使在Level 4或/W4上，它也可以在默认设置下毫无警告地进行编译。与clang 7等相同。

到目前为止，我已经设法开发了这个：

namespace dbj {
namespace util {
    using namespace std;

    template<typename T>
    struct nothing_but final
    {
        static_assert(false == std::is_array_v<T>, 
                  "can not deal with arrays");

        using type = nothing_but;

         // default creation
         nothing_but() : val_(T{}) {}
        // allowed conversion
        nothing_but(T const & t_) : val_(t_) {}
        // allowed assignment
        type & operator = (T const & new_val_)
        {
            val_ = new_val_;
            return *this;
        }

        /*
        explictly ban all attempts to construct from
        any other type but T
        */
        template<
            typename X,
            std::enable_if_t<
            false == std::is_same_v<T, X>
            , int> = 0
        >
            nothing_but(X const & x_) = delete;
        /*
        explictly ban all attempts to assign from
        any other type but T
        */
        template<
            typename X,
            std::enable_if_t<
            false == std::is_same_v<T, X>
            , int> = 0
        >
            type & operator = (X const & new_val_) = delete;

        /* conversion to X is banned */
        template<
        typename X,
        std::enable_if_t<
        false == std::is_same_v<T, X>
        , int> = 0
        >
        operator X & () = delete;

        // conversion to T is allowed, but const stays const
        operator T & () { return val_; }

        // non const value, as other std class types do
        T & data() const { return (T&)val_;  }

    private:
        T val_{};
        // compatibility
        friend bool operator < ( type const & left_, type const & right_)
        {
            return left_.val_ < right_.val_;
        }
    };
  } // util
} // dbj

一些快速测试：

{
using dbj::util::nothing_but;

nothing_but<int> si1 = 42;
si1 = 42;
nothing_but<int> si2 = 13;
//nothing_but<int> si3 = true ; 
//si3 = true;
//nothing_but<int> si4 = '$' ;
//si4 = '$';
//nothing_but<int> si5 = 2.7 ;
//si5 = 2.7;
//nothing_but<int> si6 = size_t(BUFSIZ) ;
//si6 = size_t(BUFSIZ);

si1 = si2; (void)(si1 == si2);

int j = 9;
nothing_but<int *> sip1 = &j;
nothing_but<char const *> scc1 = "OK";

char name[] = "c++";
// scc1 = name;

}

一些常数测试

{ // constnes
    const int cc = 42;
    const int cb = cc;
    nothing_but<int> const & sci1 = cc;
    nothing_but<int> const sci2 = sci1 ; // ok
    const nothing_but<int> sci3 = sci1 ; // ok

    wprintf(L"%d", sci1.data()); // ok

    //sci2 = sci1;
    //const int ii1 = sci1;
    //const int ii2 = static_cast<int>(sci1);
    //const int * ii3 = const_cast<int *>(&(sci1));
    const int & ii3 = (const int &)(sci1); // ok
    int & ii4 = (int &)(sci1); // ok
}

{ // compatibility
    // std::vector<nothing_but<bool>> bv{ true, 1 , true };
    std::vector<nothing_but<bool>> bv{ true, true , true };

    nothing_but<bool> bb = bv[1] ;
    bool kb = bb; // OK
    //int k = bb;
    //int j = bv[1];

    std::map< nothing_but<bool>, nothing_but<int> > bm;

    bm[true]  = 1;
    // bm[true]  = 2.3;
    bm[false] = 0;
    // bm[false] = 0.9;
}

以此类推。注释掉的东西都不会编译。

到目前为止，我已经看到了潜力，但是我不确定自己做对了吗？您是否会认为这很有用？如果这样做，您会有所不同吗？

请注意，我需要通用解决方案，我称之为“不可转换的基本类型”。我希望它可以完成，完成后可能很小而且通用。

Answer 1

您可以使用“方法模板重载”而不是type_traits来做到这一点：

template<typename T>
struct nothing_but final
{
    // construction
    nothing_but() = default;
    nothing_but(const T& t_)
        : val_(t_)
    {}
    template<typename Other>
    nothing_but(const Other&) = delete;

    // assignment
    nothing_but& operator=(const T& new_val_)
    {
        val_ = new_val_;
        return *this;
    }
    template<typename Other>
    nothing_but& operator=(const Other&) = delete;

    // comparison
    bool operator==(const nothing_but& rhs) const
    {
        return (val_ == rhs.val_);
    }
    bool operator<(const nothing_but& rhs) const
    {
        return (val_ < rhs.val_);
    }

    // conversion
    operator T& ()
    {
        return val_;
    }
    template<typename Other>
    operator T& () = delete;

    // non const value, as other std class types do
    T& data() const
    {
        return (T&)val_; 
    }
    template<typename Other>
    operator Other& () = delete;

private:
    T val_{};
};

非模板优先于模板（请参见C ++标准13.3.3，或在http://www.gotw.ca/gotw/049.htm中进行了解释）。

如何避免隐式可转换类型

更新

原始帖子

1 个答案: