Question

我正在处理使用析构函数来释放资源的C ++对象。将那些对象传递给带有任意数量参数的函数时。在这种情况下，有什么方法可以摆脱使用指针的麻烦？

一种可能的解决方案是将指针向量传递给那些对象。如果我自己传递对象，则析构函数将被调用两次，一个是真实对象，另一个是在释放向量时。

#include<iostream>
#include<vector>
class integer {
    private:
        int data;
    public:
        integer(int value = 0): data(value) {}
        ~integer() {}
        void increase() {
            data++;
        }
        friend std::ostream& operator<<(std::ostream& os, const integer& x);
};
std::ostream& operator<<(std::ostream& os, const integer& x) {
    os << x.data;
    return os;
}
void foo(std::vector<integer*> vec) {
    for (auto it = vec.begin(); it != vec.end(); it++) {
        (*it)->increase();
    }
}
int main() {
    integer x1(3);
    integer x2(4);
    integer x3(5);

    std::cout << x1 << " " << x2 << " " << x3 << std::endl;

    foo({&x1, &x2, &x3});

    std::cout << x1 << " " << x2 << " " << x3 << std::endl;

    return 0;
}

预期结果：

3 4 5
4 5 6

Answer 1

我不确定指针有什么问题，但是您当然可以避免使用reference_wrapper指针。（不要忘记#include <functional>）

void foo(const std::vector<std::reference_wrapper<integer>>& vec)
{
    for (auto it = vec.begin(); it != vec.end(); it++) {
        (*it)->increase();
    }
}

现在您可以像foo({x1, x2, x3})那样称呼它了。

live demo

如果需要，您甚至可以摆脱{}：

template <typename... Args>
void foo(Args&... args)
{
    static_assert(std::conjunction_v<std::is_same<Args, integer>...>);
    (args.increase(), ...);
}

（请不要忘记#include <type_traits>。）现在您可以像foo(x1, x2, x3)这样称呼它了。

Answer 2

您可以使用迭代器。超过3个后，您就不应继续使用x4，而应使用容器。您的foo将是

template <typename iterator_t>
void foo(iterator_t begin,iterator_t end) {
    for ( ; begin != end; ++begin) begin->increase();
}

在main中：

int main() {
    std::vector<integer> x { {3},{4},{5} };
    for (const auto& i : x) std::cout << i << " ";
    std::cout << "\n";

    foo(x.begin(),x.end());
    for (const auto& i : x) std::cout << i << " ";

    return 0;
}

在C ++中使用向量传递任意数量的参数

2 个答案: