編寫二進制文件模板函數

Question

我已經做了一些函數來將類寫入和讀取二進制文件。

如果參數是一個類，我只想調用第一個writeElement函數。

然后，我想在一個函數中使用int, double, size_t的其他函數。 必須有一種更好的方法來執行此操作，我不必為所有不同類型創建一個新函數。

template <class T>
inline void writeElement(ostream& out, T target) { target.write(out); }
inline void writeElement(ostream& out, int target) { out.write((char*)&target, sizeof(int)); }
inline void writeElement(ostream& out, double target) { out.write((char*)&target, sizeof(double)); }
inline void writeElement(ostream& out, size_t target) { out.write((char*)&target, sizeof(size_t)); }
inline void writeElement(ostream& out, const string str)
{
    size_t size = str.size();
    writeElement(out, size);
    out.write(&str[0], size);
}
template <class T>
inline void writeElement(ostream& out, vector<T> vector)
{
    size_t size = vector.size();
    writeElement(out, size);

    for (auto &element : vector)
    {
        writeElement(out, element);
    }
}


class Header
{
public:
    string sig;
    double  version;

public:
    void read(istream& in)
    {
        readElement(in, sig);
        readElement(in, version);
    }

    void write(ostream& out)
    {
        writeElement(out, sig);
        writeElement(out, version);
    }
};

Answer 1

然后，我想在一個函數中使用int, double, size_t的其他函數。 必須有一種更好的方法來執行此操作，我不必為所有不同類型創建一個新函數。

您可能希望為此使用“ 類特征” 類模板 ，並且有一個功能可以為您完成這項工作。

//Primary templates for every other object
template<typename T, typename = void>
struct WriteHelper{

     static void write(ostream& out, T target){
         target.write(out);
     }
};

//Specialization for integral types
template<typename T>
struct WriteHelper<T, std::enable_if_t<std::is_arithmetic<T>::value >>{

     static void write(ostream& out, T target){
         out.write((char*)&target, sizeof(T));
     }
};

//Specialization for std::string
template<typename T>
struct WriteHelper<T, std::enable_if_t<std::is_same<std::string, T>::value >>{

     static void write(ostream& out, T target){
         size_t size = str.size();
         writeElement(out, size);
         out.write(&str[0], size);
     }
};

並用作：

template<typename T, typename X = std::decay_t<T>>
inline void writeElement(ostream& out, T&& target){
      WriteHelper<X>::write(out, std::forward<T>(target));
}

Answer 2

我想有很多方法可以做到這一點。

我建議在設置constexpr值的自定義類型特征的幫助下使用SFINAE

template <typename>
struct foo { static constexpr std::size_t value { 0U }; };

template <>
struct foo<int> { static constexpr std::size_t value { 1U }; };

template <>
struct foo<double> { static constexpr std::size_t value { 1U }; };

template <>
struct foo<std::size_t> { static constexpr std::size_t value { 1U }; };

template <>
struct foo<std::string> { static constexpr std::size_t value { 2U }; };

因此，您可以使用foo<T>::value的值來啟用其他寫入功能

template <typename T>
inline typename std::enable_if<0U == foo<T>::value>::type
   writeElement (std::ostream & out, T const & t)
 { std::cout << "generic case" << std::endl; }

template <typename T>
inline typename std::enable_if<1U == foo<T>::value>::type
   writeElement (std::ostream & out, T const & t)
 { std::cout << "int, double, size_t case" << std::endl; }

template <typename T>
inline typename std::enable_if<2U == foo<T>::value>::type
   writeElement (std::ostream & out, T const & t)
 { std::cout << "string case" << std::endl; }

template <typename T>
inline void writeElement (std::ostream & out, std::vector<T> const & v)
 { std::cout << "vector case" << std::endl; }

以下是完整的工作示例

#include <set>
#include <vector>
#include <iostream>
#include <type_traits>

template <typename>
struct foo { static constexpr std::size_t value { 0U }; };

template <>
struct foo<int> { static constexpr std::size_t value { 1U }; };

template <>
struct foo<double> { static constexpr std::size_t value { 1U }; };

template <>
struct foo<std::size_t> { static constexpr std::size_t value { 1U }; };

template <>
struct foo<std::string> { static constexpr std::size_t value { 2U }; };

template <typename T>
inline typename std::enable_if<0U == foo<T>::value>::type
   writeElement (std::ostream & out, T const & t)
 { std::cout << "generic case" << std::endl; }

template <typename T>
inline typename std::enable_if<1U == foo<T>::value>::type
   writeElement (std::ostream & out, T const & t)
 { std::cout << "int, double, size_t case" << std::endl; }

template <typename T>
inline typename std::enable_if<2U == foo<T>::value>::type
   writeElement (std::ostream & out, T const & t)
 { std::cout << "string case" << std::endl; }

template <typename T>
inline void writeElement (std::ostream & out, std::vector<T> const & v)
 { std::cout << "vector case" << std::endl; }

int main ()
 {
   writeElement(std::cout, std::set<int>{});
   writeElement(std::cout, 0);
   writeElement(std::cout, 0.0);
   writeElement(std::cout, std::size_t{});
   writeElement(std::cout, std::string{"0"});
   writeElement(std::cout, std::vector<int>{});
 }

Answer 3

只需將SFINAE用於class，native和其他特殊定義的類型，例如：

    template <typename T, typename std::enable_if < std::is_class<T>::value, void >::type* = nullptr >
inline void writeElement( T  )
{
    std::cout << "Class write" << std::endl;
}

    template <typename T, typename std::enable_if<!std::is_class<T>::value, void>::type* = nullptr>
inline void writeElement( T  )
{
    std::cout << "Native type" << std::endl;
}

template <typename T>
inline void writeElement( const std::vector<T>& )
{
    std::cout << "vector" << std::endl;
}

inline void writeElement( std::string )
{
    std::cout << "string" << std::endl;
}

class A{};

int main()
{
    writeElement( A{} );
    writeElement( 1 );
    writeElement( std::vector<int>{1,2,3,4} );
    writeElement( std::string{"Hallo"});

}

因此，每個“本機類型”都可以使用一個模板函數進行處理。 您還應該查看指針，因為您不能以這種方式處理指針，因為您不能通過指針本身傳遞長度。

Answer 4

也使用SFINAE並拆分

1. 具有void write(ostream&)方法的類：

    template <typename T> typename std::enable_if<std::is_same<decltype(&T::write), void(T::*)(ostream&)>::value, void>::type writeElement(ostream& out, T& target) { target.write(out); } 

   注意最好通過引用傳遞類，以防止復制。

2. 算術類型（ int ， double ， size_t等）：

    template <typename T> typename std::enable_if<std::is_arithmetic<T>::value, void>::type writeElement(ostream& out, T target) { out.write((char*)&target, sizeof(T)); } 

   如果要包括枚舉，請使用std::is_scalar 。

3. 和std::string和std::vector<T>

    inline void writeElement(ostream& out, const string& str) { const size_t size = str.size(); writeElement(out, size); out.write(str.data(), size); // NOTE: Accessing &str[0] if the `.size() == 0` is *Undefined behavior*, use `std::string::data()` insetad } template <class T> inline void writeElement(ostream& out, const vector<T>& vector) { const size_t size = vector.size(); writeElement(out, size); for (const auto &element : vector) { writeElement(out, element); } } 

   注意如果string s &str[0]的大小為零，則訪問它會導致未定義的行為