Verilog 安全地将位/逻辑向量的SystemC结构转换为单个位/逻辑向量

我正在将代码从SystemVerilog移植到SystemC。SV能够轻松地将位/逻辑的压缩结构解释为单个位/逻辑向量。例如：

typedef struct logic {
  logic [31:0] blk1;  //63:32
  logic [4:0]  blk2;  //31:27
  logic [2:0]  blk3; //26:24
  logic [4:0]  blk4;  //23:19
  logic [2:0]  blk5;  //18:16
  logic [7:0]  blk6;  //15:8
  logic [7:0]  blk7;  //7:0
} typ_block;
...
typ_block blockA;
logic[63:0] blockB;
blockB = blockA; // no problem here

但是使用SystemC和sc_lv模板时，由于类型不匹配，这会导致编译器错误

struct typ_block {
  sc_lv<32> blk1;  //63:32
  sc_lv<5>  blk2;  //31:27
  sc_lv<3>  blk3; //26:24
  sc_lv<5>  blk4;  //23:19
  sc_lv<3>  blk5;  //18:16
  sc_lv<8>  blk6;  //15:8
  sc_lv<8>  blk7;  //7:0
};
...
typ_block blockA;
sc_lv<64> blockB;
blockB = blockA; // compiler error

结构类型块{ sc_lv blk1；//63:32 sc_lv blk2；//31:27 sc_lv blk3；//26:24 sc_lv blk4；//23:19 sc_lv blk5；//18:16 sc_lv blk6；//15:8 sc_lv blk7；//7:0 }; ... 典型区块A； sc_lv blockB； blockB=blockA；//编译错误

---

是否有一个好的SystemC支持的方法来实现这一等效功能？我可以想出一些可能的解决方案，但它们既不优雅也不简洁，而且我不确定c型指针转换是否安全/正确。

编辑：我将以下三个答案结合起来：

struct typ_block {
  sc_lv<32> blk1;  //63:32
  sc_lv<5>  blk2;  //31:27
  sc_lv<3>  blk3; //26:24
  sc_lv<5>  blk4;  //23:19
  sc_lv<3>  blk5;  //18:16
  sc_lv<8>  blk6;  //15:8
  sc_lv<8>  blk7;  //7:0

  // replacing the commented version by combining jclin's and dwinkle's answers
  // sc_lv<64> to64bit() { return (sc_lv<64>((blk1.to_string() + blk2.to_string() + blk3.to_string() + blk4.to_string() + blk5.to_string() + blk6.to_string() + blk7.to_string()).c_str())); };
  operator sc_lv<64>() const { return (blk1, blk2, blk3, blk4, blk5, blk6, blk7); };
};
...
typ_block blockA;
sc_lv<64> blockB;
blockB = blockA;

结构类型块{ sc_lv blk1；//63:32 sc_lv blk2；//31:27 sc_lv blk3；//26:24 sc_lv blk4；//23:19 sc_lv blk5；//18:16 sc_lv blk6；//15:8 sc_lv blk7；//7:0 //通过结合jclin和dwinkle的答案替换注释版本 //sc_lv to 64位（）{返回（sc_lv（（blk1.to_string（）+blk2.to_string（）+blk3.to_string（）+blk4.to_string（）+blk5.to_string（）+blk6.to_string（）+blk7.to_string（））.c_str（））； 运算符sc_lv（）常量{return（blk1，blk2，blk3，blk4，blk5，blk6，blk7）；}； }; ... 典型区块A； sc_lv blockB； B区=A区；

---

以下是对您自己答案的一点改进。您不需要转换为字符串，因为

sc_lv

类型可以与

（）

运算符连接

因此，您可以像这样简化您的函数：

sc_lv<64> to64bit() { return (blk1, blk2, blk3, blk4, blk5, blk6, blk7); };

sc_lv to 64位（）{返回（blk1、blk2、blk3、blk4、blk5、blk6、blk7）；}；

---

我想通过简单的赋值来完成简单赋值的工作是为了<代码> Type块[/COD] >，但是我不确定它是什么。< /P> < P>这是用C++类型转换操作符重载来代替<代码> to64位（）/<代码> < < 结构类型块{ sc_lv blk1；//63:32 sc_lv blk2；//31:27 sc_lv blk3；//26:24 sc_lv blk4；//23:19 sc_lv blk5；//18:16 sc_lv blk6；//15:8 sc_lv blk7；//7:0 运算符sc_lv（）常量{ 返回sc_lv（（blk1.to_string（）+blk2.to_string（）+…）.c_str（））； } }; 典型区块A； sc_lv blockB； B区=A区；

---

此C++运算符的限制是必须使用显式表达式，以便编译器知道类型转换。这意味着您不能使用like

blockB=（blockA）.range（7,0），您必须使用
blockB=sc_lv（blockA）.range（7,0）
 谢谢，这有助于清理lotdwikle，return语句如何工作？描述<代码>（BLK1，BLK2，BLK3[…]）< /> >罗斯的C++构造的名称是什么？如果我正确理解，这是因为超负荷逗号操作符被定义为SCLV和类似类的级联。大约走到一半。谢谢。这有助于清理一些。如果可以的话，我会检查你的两个答案。
struct typ_block {
    sc_lv<32> blk1;  //63:32
    sc_lv<5>  blk2;  //31:27
    sc_lv<3>  blk3; //26:24
    sc_lv<5>  blk4;  //23:19
    sc_lv<3>  blk5;  //18:16
    sc_lv<8>  blk6;  //15:8
    sc_lv<8>  blk7;  //7:0

    operator sc_lv<64>() const {
        return sc_lv<64>((blk1.to_string() + blk2.to_string() + ...).c_str());
    }
};

typ_block blockA;
sc_lv<64> blockB;
blockB = blockA;