在C 中传递多个函数参数的最佳实践

Best practice for passing multiple function arguments in C++

本文关键字：参数 最佳 函数      更新时间：2023-10-16

我想知道在C 中传递多个函数参数的最佳实践是什么。我想遵循STL中看到的适当的通用设计原理。

我具有通用算法函数。使用模板，它允许客户端选择哪些数据结构用于运行算法以及将从中绘制数据的容器实现。但是，为了重复使用，我选择了许多应插入客户端设计的代码的地方。

template<class CustomContainerIterator, class Queue, class Element>
void run_generic_algorithm(CustomContainerIterator container,
                           std::function<void(Element)> client_code1,
                           std::function<void(Element)> client_code2,
                           std::function<void(Element)> client_code3)
{
    Queue queue;
    //Push things iterated through onto the queue
    Element queue_element = queue.top();
    client_code1(queue_element);
    // Run code modifying queue
    client_code2(queue_element);  
    // Run code modifying queue
    client_code3(queue_element);    
}

客户端函数由客户端指定，可以修改客户端拥有的相同变量。在我的代码中，有5个客户端功能。我最初以lambda的表达方式将它们全部传递给我，并捕获了我想修改的客户端变量。但是，这使得非常详细的功能调用。

大多数情况下，我什至没有指定所有客户端功能，因此我必须放置一个无助的lambda函数。有一种更好的方法，可以实现我想要的东西。我想坚持适当的通用编程原则？

好的，所以我已经阅读了答案。我可以结合这样的想法吗？现在我认为我不需要虚拟功能。

template <typename Element>
struct Customization {
    void client_code1(Element) {}
    void client_code2(Element) {}
    void client_code3(Element) {}
    void client_code4(Foo) {}
    void client_code5(Bar) {}
};
template <typename Element>
struct Implementation : public Customization {
    Data some_data;
    void client_code2(Element) {
        //Fill some_data with information.
    }
};
template<class Queue, class CustomContainerIterator, class CustomImplementation>
void run_generic_algorithm(CustomContainerIterator container,
                           CustomImplementation implementation)
{
    Queue queue;
    //Push things iterated through onto the queue
    auto queue_element = queue.top();
    implementation.client_code1(queue_element);
    // Run code modifying queue
    implementation.client_code2(queue_element);  
    // Run code modifying queue
    implementation.client_code3(queue_element);    
}

用法

std::vector<int> v;
Implementation <int> custom;
run_generic_algorithm<std::queue<int>>(v, custom);

有5个客户端功能。

您可能会通过结构

template <typename Element>
struct Customization {
    std::function<void(Element)> client_code1;
    std::function<void(Element)> client_code2;
    std::function<void(Element)> client_code3;
    std::function<void(Foo)> client_code4;
    std::function<void(Bar)> client_code5;
};

甚至可能是接口：

template <typename Element>
struct Customization {
    virtual ~Customization() = default;
    virtual void client_code1(Element) = 0;
    virtual void client_code2(Element) = 0;
    virtual void client_code3(Element) = 0;
    virtual void client_code4(Foo) = 0;
    virtual void client_code5(Bar) = 0;
};

，然后

template<class Range, class Element>
void run_generic_algorithm(Range& r, const Customization <Element>& customization);

大多数情况下，我什至没有指定所有客户端功能，因此我必须放入lambda函数，无助。

使用以前的评论，您可能会给先前结构的成员默认值。

否则您可以将默认值添加到参数或创建过载。

在与您所描述的类似情况下，我将客户端函数放入类/struct中，并将类作为模板参数或实例传递。（如果函数具有从通用函数外部共享状态，则只需要传递类对象。）

我发现将功能放在一堂课中也使记录函数在通用函数中负责的内容变得更加容易。

template< class Queue >
class a_traits{
public:
   static void client_code1( Queue & );
   static void client_code2();
   static void client_code3();
};
template <class Container, class Queue, class Traits>
void run_generic_algorithm(const Container& container) {
  Queue queue;
  Traits::client_code1(queue_element);
  // Run code modifying queue
  Traits::client_code2();  
  // Run code modifying queue
  Traits::client_code3();    
}
相关文章：