我们有一些类:

struct HttpRequest {
    std::string url;
};

struct HttpResponse {
    int          status_code;
    std::string  status_text;
    std::string  content;
};

struct HttpClient {
    void execute(HttpRequest const& req, HttpResponse& resp);
};

size_t
appender(void *contents, size_t size, size_t nmemb, void *userp)
{
    auto& ct = * reinterpret_cast<std::string*>(userp);
    size_t bytes = size * nmemb;

    ct.append(reinterpret_cast<char*>(contents), bytes);
    return bytes;
}

void HttpClient::execute(HttpRequest const& req, HttpResponse& resp)
{
    auto curl = curl_easy_init();

    curl_easy_setopt(curl, CURLOPT_URL, req.url.c_str());
    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, appender);
    curl_easy_setopt(curl, CURLOPT_WRITEDATA, &resp.content);
    // header callback etc.

    CURLcode code = curl_easy_perform(curl);

    curl_easy_cleanup(curl);
    if (code != CURLE_OK) {
        throw std::runtime_error("curl fail");
    }

    return; // enjoy your HttpResponse
}

我们这样使用它们:

bool fatal(std::runtime_error const& rte) {
    return rte.what()[0] == 'F'; // if it starts with F, it's fatal
    // not the actual implementation :)
}

const int retries = 7;

int do_something(std::string const& url)
{
    HttpClient client;
    HttpRequest req{ url };

    for (int r = 0; r < retries; ++r) try {
        HttpResponse resp;

        client.execute(req, resp);
        //
        if (resp.status_code / 100 == 2) { // a 2xx success code
            return std::stoi(resp.content);
        }
        else { // maybe a 4xx client error or 5xx server error
            throw std::runtime_error("HTTP error");
        }
    }
    catch (std::runtime_error const& e) {
        if (fatal(e))
            throw;
        else
            continue; // retry
    }

    // ran out of retries
    throw std::runtime_error("out of retries");
}

一切都很好。 然而，有人实现了不同的模式:

int worker(HttpRequest const& req, HttpResponse& resp)
{
    HttpClient client;
    for (int r = 0; r < retries; ++r) try {
        client.execute(req, resp);
        //
        if (resp.status_code / 100 == 2) { // a 2xx success code
            return std::stoi(resp.content);
        }
        else { // maybe a 4xx client error or 5xx server error
            throw std::runtime_error("HTTP error");
        }
    }
    catch (std::runtime_error const& e) {
        if (fatal(e))
            throw;
        else
            continue; // retry
    }

    // ran out of retries
    throw std::runtime_error("out of retries");
}

int do_something_else(std::string const& url)
{
    HttpRequest req{ url };
    HttpResponse resp;
    return worker(req, resp);
}

现在我们发现我们在 HttpClient::execute 中有不需要的行为:如果 HttpResponse 在入口时不为空(例如，我们得到 503 服务不可用，重试，并得到 200 OK)，execute 只是附加到现有内容。这不是我们想要的:我们已经对 503 响应采取了行动，我们不希望 200 响应的内容附加到 503 响应的任何内容。

我们检查了我们的代码，发现了几个类似于 do_something 的用法，只有一个 do_something_else。我们从来不需要(意外的)附加到现有响应的能力。

问题是，我们如何解决这个问题并确保我们不会再次遇到意外？我可以看到几个选项:

• 让一切保持原样；在 do_something_else 中手动清除 HttpResponse；记录行为(不理想；人们并不总是阅读文档:)
• 更改 HttpClient::execute 以在输入时清除 HttpResponse。我不喜欢悄悄地改变同一界面背后的行为(而且我们需要改变单元测试)。
• 向清除 HttpResponse 的 HttpClient 添加包装器成员，然后调用原始 HttpClient::execute。这样做的好处是，如果我们想要附加行为，它是可用的。缺点是人们可能会无意中获得附加行为。
• 同上，但将现有的重命名为例如execute_append 并调用新的 execute(同样，同一接口(interface)背后的不同行为)。
• 更改 execute 以仅接受 HttpRequest 并按值返回 HttpResponse。因为总是在 execute 中创建一个新的 HttpResponse，所以追加不是问题。 NRVO 之后保留的任何性能损失在执行 HTTP 时，毫秒级到秒级的延迟相形见绌。真正的缺点是我们有几个单元测试，其中 HttpClient::execute 是通过 googlemock 模拟的。如果我们更改签名，我们将不得不更改所有模拟，并且执行 SetArgReferee 的每个期望都必须更改为 Returns。

有什么建议吗？

最佳答案

HttpClient::execute 的工作似乎是发送一个 HTTP 请求，并返回一个响应。

如果是这样，那么将 HttpResponse 对象作为参数传递给它就没有意义了。

execute() 应该只接受一个 req 参数，并返回 HttpResponse。

由于移动语义，现代 C++11 编译器将优化大部分返回非 POD 对象的开销，为您留下干净、明确的代码，没有潜在的副作用。

关于c++ - 如何更改方法中不需要的行为，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/37448093/