Mã trùng lặp bằng c ++ 11

Tôi hiện đang làm việc trong một dự án và tôi gặp sự cố sau.

Tôi có một phương thức C ++ mà tôi muốn làm việc theo hai cách khác nhau:

void MyFunction()
{
  foo();
  bar();
  foobar();
}

void MyFunctionWithABonus()
{
  foo();
  bar();
  doBonusStuff();
  foobar();
}

Và tôi không muốn sao chép mã của mình vì chức năng thực tế dài hơn nhiều. Vấn đề là tôi không được thêm thời gian thực thi vào chương trình trong bất kỳ trường hợp nào khi MyFunction được gọi thay vì MyFunctionWithABonus. Đó là lý do tại sao tôi không thể chỉ có một tham số boolean mà tôi kiểm tra bằng so sánh C ++.

Ý tưởng của tôi là sử dụng các mẫu C ++ để sao chép hầu như mã của mình, nhưng tôi không thể nghĩ ra cách làm mà tôi không có thêm thời gian thực thi và không phải sao chép mã.

Tôi không phải là chuyên gia về các mẫu nên tôi có thể thiếu một thứ gì đó.

Có ai trong số bạn có một ý tưởng? Hay đó chỉ là điều không thể trong C ++ 11?

Với mẫu và lambda, bạn có thể làm:

template <typename F>
void common(F f)
{
  foo();
  bar();
  f();
  foobar();
}

void MyFunction()
{
    common([](){});
}

void MyFunctionWithABonus()
{
  common(&doBonusStuff);
}

hoặc nếu không bạn chỉ có thể tạo prefixvà suffixhoạt động.

void prefix()
{
  foo();
  bar();
}

void suffix()
{
    foobar();
}

void MyFunction()
{
    prefix();
    suffix();
}

void MyFunctionWithABonus()
{
    prefix();
    doBonusStuff();
    suffix();
}

Một cái gì đó như vậy sẽ làm tốt:

template<bool bonus = false>
void MyFunction()
{
  foo();
  bar();
  if (bonus) { doBonusStuff(); }
  foobar();
}

Gọi nó qua:

MyFunction<true>();
MyFunction<false>();
MyFunction(); // Call myFunction with the false template by default

Tất cả các mẫu "xấu xí" có thể được tránh bằng cách thêm một số trình bao bọc đẹp vào các chức năng:

void MyFunctionAlone() { MyFunction<false>(); }
void MyFunctionBonus() { MyFunction<true>(); }

Bạn có thể tìm thấy một số thông tin tốt về kỹ thuật đó ở đó . Đó là một bài báo "cũ", nhưng kỹ thuật tự nó vẫn hoàn toàn đúng.

Với điều kiện bạn có quyền truy cập vào một trình biên dịch C ++ 17 đẹp, bạn thậm chí có thể đẩy mạnh kỹ thuật này hơn nữa, bằng cách sử dụng constexpr nếu , như thế:

template <int bonus>
auto MyFunction() {
  foo();
  bar();
  if      constexpr (bonus == 0) { doBonusStuff1(); }
  else if constexpr (bonus == 1) { doBonusStuff2(); }
  else if constexpr (bonus == 2) { doBonusStuff3(); }
  else if constexpr (bonus == 3) { doBonusStuff4(); }
  // Guarantee that this function will not compile
  // if a bonus different than 0,1,2,3 is passer
  else { static_assert(false);}, 
  foorbar();
}

Với một số nhận xét mà OP đã đưa ra liên quan đến việc gỡ lỗi, đây là phiên bản yêu doBonusStuff()cầu các bản dựng gỡ lỗi, nhưng không phát hành các bản dựng (định nghĩa NDEBUG):

#if defined(NDEBUG)
#define DEBUG(x)
#else
#define DEBUG(x) x
#endif

void MyFunctionWithABonus()
{
  foo();
  bar();
  DEBUG(doBonusStuff());
  foobar();
}

Bạn cũng có thể sử dụng assertmacro nếu bạn muốn kiểm tra một điều kiện và thất bại nếu nó sai (nhưng chỉ dành cho các bản dựng gỡ lỗi; các bản dựng phát hành sẽ không thực hiện kiểm tra).

Hãy cẩn thận nếu doBonusStuff()có tác dụng phụ, vì những tác dụng phụ này sẽ không có trong các bản phát hành và có thể làm mất hiệu lực của các giả định được đưa ra trong mã.

Đây là một biến thể nhỏ về câu trả lời của Jarod42 bằng cách sử dụng các mẫu khác nhau để người gọi có thể cung cấp không hoặc một chức năng bổ sung:

void callBonus() {}

template<typename F>
void callBonus(F&& f) { f(); }

template <typename ...F>
void MyFunction(F&&... f)
{
  foo();
  bar();
  callBonus(std::forward<F>(f)...);
  foobar();
}

Mã gọi:

MyFunction();
MyFunction(&doBonusStuff);

Một phiên bản khác, chỉ sử dụng các mẫu và không có chức năng chuyển hướng, vì bạn đã nói rằng bạn không muốn bất kỳ chi phí thời gian chạy nào. Như tôi lo ngại, điều này chỉ làm tăng thời gian biên dịch:

#include <iostream>

using namespace std;

void foo() { cout << "foo\n"; };
void bar() { cout << "bar\n"; };
void bak() { cout << "bak\n"; };

template <bool = false>
void bonus() {};

template <>
void bonus<true>()
{
    cout << "Doing bonus\n";
};

template <bool withBonus = false>
void MyFunc()
{
    foo();
    bar();
    bonus<withBonus>();
    bak();
}

int main(int argc, const char* argv[])
{
    MyFunc();
    cout << "\n";
    MyFunc<true>();
}

output:
foo
bar
bak

foo
bar
Doing bonus
bak

Bây giờ chỉ có một phiên bản MyFunc()với booltham số làm đối số mẫu.

Bạn có thể sử dụng điều phối thẻ và quá tải chức năng đơn giản:

struct Tag_EnableBonus {};
struct Tag_DisableBonus {};

void doBonusStuff(Tag_DisableBonus) {}

void doBonusStuff(Tag_EnableBonus)
{
    //Do bonus stuff here
}

template<class Tag> MyFunction(Tag bonus_tag)
{
   foo();
   bar();
   doBonusStuff(bonus_tag);
   foobar();
}

Điều này rất dễ đọc / dễ hiểu, có thể được mở rộng mà không tốn nhiều công sức (và không có ifmệnh đề viết sẵn - bằng cách thêm nhiều thẻ hơn) và tất nhiên sẽ không để lại dấu vết thời gian chạy.

Cú pháp gọi của nó khá thân thiện, nhưng tất nhiên có thể được gói gọn trong các cuộc gọi vani:

void MyFunctionAlone() { MyFunction(Tag_DisableBonus{}); }
void MyFunctionBonus() { MyFunction(Tag_EnableBonus{}); }

Điều phối thẻ là một kỹ thuật lập trình chung được sử dụng rộng rãi, đây là một bài viết hay về những điều cơ bản.