Question

我有三种类型的数据链接：RS485，I2C和蓝牙。每个数据链路都具有连接，读取和写入数据等功能。在PC软件上，我必须实现应用程序/协议层以使用设备。在我之前关于OOP的问题中，我得到了使用Bridge模式或工厂方法的答案，但我认为这可以做得更好。我会问是否更好地使用模板来完成这项任务。以下是我想要使用它的简单示例：

@Given("App launch")
def step(context):
    context={}
    context["currentpage"] = "current page info here"

@When("Next button selected")
def step(context):
    step = context["currentpage"]

Answer 1

根据经验 - 不要优化（还）。如果对send的虚拟调用不是瓶颈，为什么还要用具有更多样板代码的模板替换接口呢？

从您的代码中看，似乎没有必要去追求任何模式 - 只需对这些类进行硬编码，您就可以更快地完成工作。

编辑：如果你真的想将协议链接在一起，这里有一个功能性的方法：

struct TCP
{
    void onsend(const char* data) {}
};

struct MODBUS
{
    void onsend(const char* data) {}
};

struct RS485
{
    void onsend(const char* data) {}
};

template<typename F, typename Prot, typename... TProtocols>
auto channel(F&& f, Prot&& prot, TProtocols&&... protocols)
{
    return [&](const char* data)
    {
        f(prot, data);
        channel(f, protocols...)(data);
    };
}

template<typename F, typename Prot>
auto channel(F&& f, Prot&& prot)
{
    return [&](const char* data)
    {
        f(prot, data);
    };
}

int main()
{
    TCP tcp;
    MODBUS modbus;
    RS485 rs;

    auto chan = channel([](auto&& protocol, const char* data)
    {
        protocol.onsend(data);
    }, 
    tcp, modbus, rs);

    const char msg[] = "asdfasdf";
    chan(msg);
}

基本上，您希望对象逐个接收消息，谁说他们的类型需要相关？

Answer 2

您可以使用 mixins-from-below 来减少样板。它与您的示例没有多大区别，但您的代码较少且没有指针。您仍然可以（让我说）从其各个部分撰写您的协议以下是您重新使用它们的片段：

#include<cstdio>

// Low level datalink class
struct RS485 {
    void send(const char *data) {
        // datalink function to send data using RS485
        printf("RS485: %s \n", data);
    }
};

struct I2C {
    void send(const char *data) {
        // datalink function to send data using I2C
        printf("I2C: %s \n", data);
    }
};

struct BT {
    void send(const char *data) {
        // datalink function to send data using Bluetooth
        printf("BT %s \n", data);
    }
};

// Protocol class
template<typename Comm>
struct MODBUS: private Comm {
    void send(const char *data) {
        printf("MODBUS\n");
        Comm::send(data);
    }
};

// Protocol class
template<typename Comm>
struct TCP: private Comm {
    void send(const char *data) {
        printf("TCP\n");
        Comm::send(data);
    }
};

int main() {
    // Modbus over I2C
    MODBUS<I2C> mb_i2c{};
    mb_i2c.send("Data ...");

    // Modbus over RS485
    MODBUS<RS485> mb_rs{};
    mb_rs.send("Data ...");

    // Tcp over Modbus over RS485
    TCP< MODBUS<RS485> > tcp_modbus_rs{};
    tcp_modbus_rs.send("Data ...");
}

如果您的部件具有接受不同参数列表的构造函数，则可以使用转发引用和模板化构造函数来满足要求。
举个例子：

// Protocol class
template<typename Comm>
struct MODBUS: private Comm {
    template<typename... T>
    MODBUS(T&&... t): Comm{std::forward<T>(t)...} {}

    void send(const char *data) {
        printf("MODBUS\n");
        Comm::send(data);
    }
};

以下是以这种方式重写的完整示例：

#include<cstdio>
#include<utility>

// Low level datalink class
struct RS485 {
    RS485(int) {}

    void send(const char *data) {
        // datalink function to send data using RS485
        printf("RS485: %s \n", data);
    }
};

struct I2C {
    I2C(char, double) {}

    void send(const char *data) {
        // datalink function to send data using I2C
        printf("I2C: %s \n", data);
    }
};

struct BT {
    void send(const char *data) {
        // datalink function to send data using Bluetooth
        printf("BT %s \n", data);
    }
};

// Protocol class
template<typename Comm>
struct MODBUS: private Comm {
    template<typename... T>
    MODBUS(T&&... t): Comm{std::forward<T>(t)...} {}

    void send(const char *data) {
        printf("MODBUS\n");
        Comm::send(data);
    }
};

// Protocol class
template<typename Comm>
struct TCP: private Comm {
    template<typename... T>
    TCP(T&&... t): Comm{std::forward<T>(t)...} {}

    void send(const char *data) {
        printf("TCP\n");
        Comm::send(data);
    }
};

int main() {
    // Modbus over I2C
    MODBUS<I2C> mb_i2c{'c', .3};
    mb_i2c.send("Data ...");

    // Modbus over RS485
    MODBUS<RS485> mb_rs{42};
    mb_rs.send("Data ...");

    // Tcp over Modbus over RS485
    TCP< MODBUS<RS485> > tcp_modbus_rs{23};
    tcp_modbus_rs.send("Data ...");
}

Answer 3

在这种情况下，模板解决方案似乎不太好。

你真的希望对象的类型取决于“实现”的内容吗？

使用虚函数似乎是正确的方法（将指针传递给较低级别的通道作为构造函数中的基类指针）。

虚函数方法需要使用指针并仔细处理生命周期，但为此标准解决方案是使用智能指针。

#include <stdio.h>
#include <memory>

struct DataLink {
    virtual void send(const char *data) = 0;
    virtual ~DataLink(){}
};

typedef std::shared_ptr<DataLink> DLPtr;

struct RS485 : DataLink {
    void send(const char *data) { printf("RS485: %s \n", data);}
};

struct I2C : DataLink {
    void send(const char *data) { printf("I2C: %s \n", data); }
};

struct BT : DataLink {
    void send(const char *data) { printf("BT %s \n", data); }
};

struct MODBUS : DataLink {
    DLPtr channel;
    MODBUS(const DLPtr& channel) : channel(channel) {}
    void send(const char *data) {
        printf("MODBUS\n");
        channel->send(data);
    }
};

struct TCP : DataLink {
    DLPtr channel;
    TCP(const DLPtr& channel) : channel(channel) {}
    void send(const char *data) {
        printf("TCP\n");
        channel->send(data);
    }
};

int main() {
    DLPtr dl1(new MODBUS(DLPtr(new I2C)));
    dl1->send("data ...");
    DLPtr dl2(new MODBUS(DLPtr(new RS485)));
    dl2->send("data ...");
    DLPtr dl3(new TCP(DLPtr(new MODBUS(DLPtr(new RS485)))));
    dl3->send("data ...");
    return 0;
}

Answer 4

尽管可以使用模板，但使用多态类并不复杂：

class Sender
{
public:
    virtual ~Sender() = default;
    virtual void send(const char *data) = 0;
};

// Low level datalink class
class RS485 : public Sender
{
public:
    void send(const char *data) override {
        // datalink function to send data using RS485
        printf("RS485: %s \n", data);
    }
};

class I2C: public Sender
{
public:
    void send(const char *data) override {
        // datalink function to send data using I2C
        printf("I2C: %s \n", data);
    }
};

class BT : public Sender
{
public:
    void send(const char *data) override {
        // datalink function to send data using Bluetooth
        printf("BT %s \n", data);
    }
};

// Protocol class
class MODBUS : public Sender
{
public:
    explicit MODBUS(Sender* sender) : sender(sender) {}

    void send(const char *data) override {
        printf("MODBUS\n");
        sender->send(data);
    }
private:
    Sender *sender;
};

// Protocol class
class TCPS : public Sender
{
public:
    expolicit TCP(Sender* sender) : sender(sender) {}

    void send(const char *data) override {
        printf("TCP\n");
        sender->send(data);
    }
private:
    Sender* sender;
};

int main() {
    // Modbus over I2C
    I2C i2c;
    MODBUS mb_i2c(&i2c);
    mb_i2c.send("Data ...");

    // Modbus over RS485
    RS485 rs;
    MODBUS mb_rs(&rs);
    mb_rs.send("Data ...");

    // Tcp over Modbus over RS485
    TCP tcp_modbus_rs(mb_rs);
    tcp_modbus_rs.send("Data ...");
}

Answer 5

// strong typedef:
struct sink:std::function<void(char const*)>{
  using std::function<void(char const*)>::function; // inherit ctors
};
using step=std::function<void(char const*, sink)>;

inlne sink operator|( step s, sink e ){
  return [=](char const* data){
    s( data, e );
  };
}
inlne step operator|( step one, step two ){
  return [=](char const* data, sink end){
    two( data, one|end );
  };
}

现在我们可以连锁。

step fake_step(sts::string name){
  return [name](char const* data, sink s){
    std::cout<<name<<": \n";
    s(data);
  };
}
auto tcp=fake_step("tcp");
auto modbus=fake_step("modbus");

sink fake_sink(std::string name){
  return [name](char const* data){
    std::cout << name << ": " << data << "\n";
  };
}
auto ABC=fake_sink("ABC");
auto XYZ=fake_sink("XYZ");


auto tcp_over_xyz = tcp|XYZ;

这使用类型擦除; crtp或koenig运营商可以删除该擦除。还有更多样板文件，只有在您首次分析性能影响时才会这样做。

这使用std :: function;你可以写其他方式。

在C ++中使用模板而不是桥接模式

5 个答案: