将一组类转换为类模板并避免构造函数模棱两可

Converting a set of classes to class templates and avoiding constructor ambiguity

本文关键字：模棱两可 构造函数 转换 一组      更新时间：2023-10-16

我会尽力使这个问题尽可能短，但是要显示大量的代码，以便一个人了解我要实现的目标以及如何解决我当前的问题。

这是我与所有构造函数的原始类声明：

register.h - 原始版本

#include <bitset>
#include <cassert>
#include <cstdint>
#include <iostream>
typedef std::uint8_t u8;
typedef std::uint16_t u16;
typedef std::uint32_t u32;
typedef std::uint64_t u64;
const u16 BYTE = 0x08, WORD = 0x10, DWORD = 0x20, QWORD = 0x40;
typedef std::bitset<BYTE> Byte;
typedef std::bitset<WORD> Word;
typedef std::bitset<DWORD> DWord;
typedef std::bitset<QWORD> QWord;
template<typename T>
void getByteFrom(T val, u8 idx, u8& res) {
    res = ((val >> (idx * 8) & 0xff));
}
template<typename T>
void getWordFrom(T val, u8 idx, u16& res) {
    res = ((val >> (idx * 16) & 0xffff));
}
template<typename T>
void getDWordFrom(T val, u8 idx, u32& res) {
    res = ((val >> (idx * 32) & 0xffffffff));
}
template<typename T>
struct Register {
    T data;
    Register() = default;
};
struct Reg8 : public Register<u8> {
    u8 value;  // must be declared before std::bitset<T>
    Byte bits;
    // Default 0 Initialized Constructor
    Reg8() : value{ 0 }, bits{ value } { this->data = 0; }
    // Constructors by Register Sized Values
    explicit Reg8(u8 val)  : value{ val }, bits{ value } {
        this->data = value;
    }
    explicit Reg8(u16 val) : value{ static_cast<u8>( val ) }, bits{ value } {
        this->data = value;
    }
    explicit Reg8(u32 val) : value{ static_cast<u8>( val ) }, bits{ value } {
        //this->data = value;
    }
    explicit Reg8(u64 val) : value{ static_cast<u8>( val ) }, bits{ value } {
        //this->data = value;
    }
    Reg8(u16 val, u8 idx ) {
        assert( idx == 0 || idx == 1 );
        getByteFrom(val, idx, this->value);
        bits = value;
        this->data = value;
    }
    Reg8(u32 val, u8 idx) {
        assert(idx <= 0 && idx >= 3);
        getByteFrom(val, idx, this->value);
        bits = value;
        this->data = value;
    }
    Reg8(u64 val, u8 idx) {
        assert(idx <= 0 && idx >= 7);
        getByteFrom(val, idx, this->value);
        bits = value;
        this->data = value;
    }
    // Constructors by Register Types
    template<typename T>
    explicit Reg8(Register<T>* reg) {
        this->value = static_cast<u8>( reg->data );
        this->bits = value;
    }
};
struct Reg16 : public Register<u16> {
    u16  value;  // must be declared before std::bitset<T>
    Word bits;
    // Default 0 Initialized Constructor
    Reg16() : value{ 0 }, bits{ value } { this->data = 0; }
    // Constructors by Register Sized Values
    explicit Reg16(u16& val) : value{ val }, bits{ value } {
        this->data = value;
    }
    explicit Reg16( u8& val) : value{ val }, bits{ value } {
        this->data = value;
    }
    explicit Reg16(u32& val) : value{ static_cast<u16>(val) }, bits{ value } {
        this->data = value;
    }
    explicit Reg16(u64& val) : value{ static_cast<u16>(val) }, bits{ value } {
        this->data = value;
    }
    Reg16( u32 val, u8  idx) {
        assert(idx == 0 || idx == 1);
        getWordFrom(val, idx, this->value);
        bits = value;
        this->data = value;
    }
    Reg16(u64 val, u8 idx) {
        assert(idx <= 0 || idx <= 3);
        getWordFrom(val, idx, this->value);
        bits = value;
        this->data = value;
    }
    // Constructors by Register Types
    template<typename T>
    explicit Reg16(Register<T>* reg) {
        this->value = static_cast<u16>(reg->data);
        this->bits = value;
    }
};
struct Reg32 : public Register<u32> {
    u32 value;  // must be declared before std::bitset<T>
    DWord bits;
    // Default 0 Initialized Constructor
    Reg32() : value{ 0 }, bits{ value } { this->data = 0; }
    // Constructors by Register Sized Values
    explicit Reg32(u32& val) : value{ val }, bits{ value } {
        this->data = value;
    }
    explicit Reg32( u8& val) : value{ val }, bits{ value } {
        this->data = value;
    }
    explicit Reg32(u16& val) : value{ val }, bits{ value } {
        this->data = value;
    }
    explicit Reg32(u64& val) : value{ static_cast<u32>(val) }, bits{ value } {
        this->data = value;
    }   
    Reg32(u64 val, u8 idx) {
        assert(idx == 0 || idx == 1);
        getDWordFrom(val, idx, this->value);
        bits = value;
        this->data = value;
    }
    // Constructors by Register Types
    template<typename T>
    explicit Reg32(Register<T>* reg) {
        this->value = static_cast<u32>(reg->data);
        this->bits = value;
    }
};
struct Reg64 : public Register<u64> {
    u64 value;  // must be declared before std::bitset<T>
    QWord bits;
    // Default 0 Initialized Constructor
    Reg64() : value{ 0 }, bits{ value } { this->data = 0; }
    // Constructors by Register Sized Values
    explicit Reg64(u64& val) : value{ val }, bits{ value }{
        this->data = value;
    }
    explicit Reg64( u8& val) : value{ val }, bits{ value } {
        this->data = value;
    }
    explicit Reg64(u16& val) : value{ val }, bits{ value } {
        this->data = value;
    }
    explicit Reg64(u32& val) : value{ val }, bits{ value } {
        this->data = value;
    }

    // Constructors by Register Types
    template<typename T>
    explicit Reg64(Register<T>* reg) {
        this->value = static_cast<u64>(reg->data);
        this->bits = value;
    }
};
std::ostream& operator<<(std::ostream& os, const Reg8& r);
std::ostream& operator<<(std::ostream& os, const Reg16& r);
std::ostream& operator<<(std::ostream& os, const Reg32& r);
std::ostream& operator<<(std::ostream& os, const Reg64& r);

现在，我去了这些模板类，以减少许多代码重复。这就是我到目前为止所拥有的：

register.h - 新版本

template<typename Ty>
struct Register_t {
    static constexpr u16 BitCount = sizeof(Ty) * CHAR_BIT;
    Ty currentValue;
    Ty previousValue;
    std::bitset<BitCount> bits;
    Register_t() : 
        currentValue{ 0 }, 
        previousValue{ 0 }, 
        bits{ 0 }{}
    template<typename U>
    explicit Register_t(U val) : 
        currentValue{ static_cast<Ty>(val) }, 
        previousValue{ 0 }, 
        bits{ currentValue } {}
    template<typename U>
    explicit Register_t(Register_t<U>& r) {
        this->currentValue = static_cast<Ty>(r->currentValue);
        this->bits = r->bits;
    }        
};
template<typename Ty>
struct Register : public Register_t<Ty> {
    Register() = default;
    explicit Register(Ty val) : Register_t<Ty>( val ) {}    
    // Reg8
    template<typename U>
    Register( u16 val, u8 idx) {
        assert(idx == 0 || idx == 1);
        getByteFrom(val, idx, currentValue);
        this->bits = this->currentValue;
    }
    Register(u32 val, u8 idx) {
        assert(idx <= 0 && idx >= 3);
        getByteFrom(val, idx, this->currentValue);
        this->bits = this->currentValue;
    }
    Register(u64 val, u8 idx) {
        assert(idx <= 0 && idx <= 7);
        getByteFrom(val, idx, this->currentValue);
        this->bits = this->currentValue;
    }
    // Reg16
    Register(u32 val, u8 idx) {
        assert(idx == 0 || idx == 1);
        getWordFrom(val, idx, this->currentValue);
        this->bits = this->currentValue;
    }
    Register(u64 val, u8 idx) {
        assert(idx <= 0 && idx <= 3);
        getWordFrom(val, idx, this->currentValue);
        this->bits = this->currentValue;
    }
    // Reg32
    Register(u64 val, u8 idx) {
        assert(idx == 0 || idx == 1);
        getDWordFrom(val, idx, this->currentValue);
        this->bits = this->currentValue;
    }
};
using Reg8  = Register<u8>;
using Reg16 = Register<u16>;
using Reg32 = Register<u32>;
using Reg64 = Register<u64>;

现在，当涉及将使用std::uintx_t类型以及索引值的构造函数时。例如，某些构造函数声明匹配：

在原始版本中，Reg8具有Reg8(u32 val, u8 idx)，Reg16具有Reg16(u32 val, u8 idx)。如果您近距离查看Reg8(...)，则在Reg16(...)中断言idx <= 0 && idx >= 3，断言idx == 0 || idx == 1。

但是，当我尝试在构造函数上模板和端口模板时，这些类和端口现在变得模棱两可。我不知道如何确定要区分它是Reg8，Reg16，Reg32等的主张...

对我来说，您的班级中的所有内容都归结为使用您类型的无符号版本的sizeof和numeric_limits::max。

我在我认为班级的外观的粗略草稿下为您写信：

template <typename T>
struct Register {
    T data;
    T value;
    bitset<sizeof(T) * CHAR_BIT> bits;
    Register() : data(), value() {}
    template <typename P>
    explicit Register(const P val) : data(static_cast<T>(val)), value(data), bits(data) {}
    template <typename P>
    Register(const P val, const unsigned char idx) : data(static_cast<T>((val >> std::size(bits) * idx) & numeric_limits<make_unsigned_t<T>>::max())), value(data), bits(data) {
        assert(idx == '' || idx < sizeof(P) / sizeof(T));
    }
    template <typename P>
    Register(const Register<P>& reg) : data(static_cast<T>(reg.data)), value(data), bits(data) {}
};
template <typename T>
ostream& operator<<(ostream& os, const Register<T>& r) {
  os << "Reg" << size(r.bits) << '(' << r.data << ")nhex: 0x" << uppercase << setfill('0') << setw(sizeof(T) * 2) << hex << r.data << dec << "nbin: ";
  for(std::size_t i = 0; i < size(r.bits); ++i) {
    cout.put('0' + r.bits[i]);
  }
  return os << endl << endl;
}
template <>
ostream& operator<<<unsigned char>(ostream& os, const Register<unsigned char>& r) {
  os << "Reg" << size(r.bits) << '(' << static_cast<int>(r.data) << ")nhex: 0x" << uppercase << setfill('0') << setw(sizeof(unsigned char) * 2) << hex << static_cast<int>(r.data) << dec << "nbin: ";
  for(std::size_t i = 0; i < size(r.bits); ++i) {
    cout.put('0' + r.bits[i]);
  }
  return os << endl << endl;
}

如果要确定类型并做出适当反应，那么为什么要完全使用通用模板？有两个选项，确定类型和分支(通过完全不使用模板，通过专门使用模板或使用SFINAE(或WRITE real 通用代码。前者不是很有用，因为您最终将获得比没有模板更多的锅炉板。

后者取决于您的要求，但看起来像这样：

template <typename T>
T getXFrom(T val, std::uint8_t idx) {
  return val >> (idx * CHAR_BIT);
}
template <typename T>
class Register {
 public:
  template <typename U>
  Register(U val, std::uint8_t idx) {
    static_assert(std::is_integral_v<U>);
    assert(idx >= 0 && idx < sizeof(U));
    currentValue = getXFrom(val, idx);
  }
 private:
  T currentValue;
};

按照要求，这是如何专业化的示例(使用基类减少裁员(：

template <typename T>
class Register {
 protected:
  T currentValue;
};
template <typename>
class RegisterImpl;
template <>
class RegisterImpl<uint8_t> : Register<uint8_t> {
 public:
  template <typename U>
  RegisterImpl(U val, std::uint8_t idx) {
    // uint8_t asserts...
  }
};
template <>
class RegisterImpl<uint16_t> : Register<uint16_t> {
 public:
  template <typename U>
  RegisterImpl(U val, std::uint8_t idx) {
    // uint16_t asserts...
  }
};

我认为我已经解决了问题；我能够编译，构建和运行，并且得到了一些预期的结果，但是我没有进行足够的单元测试来验证所有案例是否按预期工作，但这是我到目前为止提出的。我分别将代码分别分为两个文件，以使其工作...

register.h 

#pragma once
#include <algorithm>
#include <assert.h>
#include <bitset>
#include <cstdint>
namespace vpc {
    typedef std::int8_t  i8;
    typedef std::int16_t i16;
    typedef std::int32_t i32;
    typedef std::int64_t i64;
    typedef std::uint8_t u8;
    typedef std::uint16_t u16;
    typedef std::uint32_t u32;
    typedef std::uint64_t u64;
    const u16 BYTE = 0x08;
    const u16 WORD = 0x10;
    const u16 DWORD = 0x20;
    const u16 QWORD = 0x40;
    typedef std::bitset<BYTE>  Byte;
    typedef std::bitset<WORD>  Word;
    typedef std::bitset<DWORD> DWord;
    typedef std::bitset<QWORD> QWord;
    // Helper Functions
    template<typename T>
    void getByteFrom(T val, u8 idx, u8& res) {
        res = ((val >> (idx * 8) & 0xff));
    }
    template<typename T>
    void getWordFrom(T val, u8 idx, u16& res) {
        res = ((val >> (idx * 16) & 0xffff));
    }
    template<typename T>
    void getDWordFrom(T val, u8 idx, u32& res) {
        res = ((val >> (idx * 32) & 0xffffffff));
    }
    template<typename T>
    struct Register_t {
        static constexpr u16 BitCount = sizeof(T) * CHAR_BIT;
        T currentValue;
        T previousValue;
        std::bitset<BitCount> bits;
        Register_t() :
            currentValue{ 0 }, 
            previousValue{ 0 }, 
            bits{ 0 }
        {}
        template<typename U>
        explicit Register_t(U val) : 
            currentValue{ static_cast<T>(val) }, 
            previousValue{ 0 }, 
            bits{ currentValue }
        {}
        template<typename U>
        explicit Register_t(Register_t<U>& r) : previousValue{ 0 }
        {
            this->currentValue = static_cast<T>(r.currentValue);
            this->bits = currentValue;
        }        
    };
    template<typename T>
    struct Register : public Register_t<T> {
        Register() : Register_t<T>() {}
        explicit Register(T val) : Register_t<T>( val ) {}  
        template<typename U>
        explicit Register(Register_t<U>& r) : Register_t<T>( r ) {}
       // These are the constructors with matching declarations
       // that were giving me trouble with ambiguous calls
       Register(u16 val, u8 idx);
       Register(u32 val, u8 idx);
       Register(u64 val, u8 idx);
    };
    using Reg8 = Register<u8>;
    using Reg16 = Register<u16>;
    using Reg32 = Register<u32>;
    using Reg64 = Register<u64>;
    std::ostream& operator<<(std::ostream& os, const Reg8&  reg);
    std::ostream& operator<<(std::ostream& os, const Reg16& reg);
    std::ostream& operator<<(std::ostream& os, const Reg32& reg);
    std::ostream& operator<<(std::ostream& os, const Reg64& reg);
} // namespace vpc

我现在在Register.cpp中定义了它们，以防止LNK Error 2005 - object already defined。

register.cpp 

#include "Register.h"
#include <iostream>
#include <iomanip>
namespace vpc {
    template<>
    Register<u8>::Register(u16 val, u8 idx) {
        assert(idx == 0 || idx == 1);
        getByteFrom(val, idx, currentValue);
        this->bits = this->currentValue;
    }
    template<>
    Register<u8>::Register(u32 val, u8 idx) {
        assert(idx >= 0 && idx <= 3);
        getByteFrom(val, idx, this->currentValue);
        this->bits = this->currentValue;
    }
    template<>
    Register<u8>::Register(u64 val, u8 idx) {
        assert(idx >= 0 && idx <= 7);
        getByteFrom(val, idx, this->currentValue);
        this->bits = this->currentValue;
    }
    // Reg16
    template<>
    Register<u16>::Register(u32 val, u8 idx) {
        assert(idx == 0 || idx == 1);
        getWordFrom(val, idx, this->currentValue);
        this->bits = this->currentValue;
    }
    template<>
    Register<u16>::Register(u64 val, u8 idx) {
        assert(idx >= 0 && idx <= 3);
        getWordFrom(val, idx, this->currentValue);
        this->bits = this->currentValue;
    }
    // Reg32
    template<>
    Register<u32>::Register(u64 val, u8 idx) {
        assert(idx == 0 || idx == 1);
        getDWordFrom(val, idx, this->currentValue);
        this->bits = this->currentValue;
    }
    std::ostream& operator<<(std::ostream& os, const Reg8& r) {
        os << "Reg8(" << +r.currentValue << ")n"
            << "hex: " << "0x" << std::uppercase
            << std::setfill('0') << std::setw(2) << std::hex
            << +r.currentValue << std::dec << 'n'
            << "bin: " << r.bits << 'n' << std::endl;
        return  os;
    }
    std::ostream& operator<<(std::ostream& os, const Reg16& r) {
        os << "Reg16(" << r.currentValue << ")n"
            << "hex: " << "0x" << std::uppercase
            << std::setfill('0') << std::setw(4) << std::hex
            << r.currentValue << std::dec << 'n'
            << "bin: " << r.bits << 'n' << std::endl;
        return  os;
    }
    std::ostream& operator<<(std::ostream& os, const Reg32& r) {
        os << "Reg32(" << r.currentValue << ")n"
            << "hex: " << "0x" << std::uppercase
            << std::setfill('0') << std::setw(8) << std::hex
            << r.currentValue << std::dec << 'n'
            << "bin: " << r.bits << 'n' << std::endl;
        return  os;
    }
    std::ostream& operator<<(std::ostream& os, const Reg64& r) {
        os << "Reg64(" << r.currentValue << ")n"
            << "hex: " << "0x" << std::uppercase
            << std::setfill('0') << std::setw(16) << std::hex
            << r.currentValue << std::dec << 'n'
            << "bin: " << r.bits << 'n' << std::endl;
        return  os;
    }
} // namespace vpc

现在我的申请程序：

main.cpp 

#include <iostream>
#include "Register.h"
int main() {
    using namespace vpc;
    u16 val = 1420;
    Reg16 r16(val);     // used to show a 16 bit register
    Reg8  r8A(val, 0);  // construct an 8 bit register from low byte of val
    Reg8  r8B(val, 1);  // construct an 8 bit register from high byte of val    
    std::cout << r16 << r8A << r8B;
    return EXIT_SUCCESS;
}

，我正在获得输出：

Reg16(1420)
hex: 0x058C
bin: 0000010110001100
Reg8(140)
hex: 0x8C
bin: 10001100
Reg8(5)
hex: 0x05
bin: 00000101
相关文章：