Статический, если на простом С++?

Ответ 1

Цитата @JohannesSchaubLitb

с моим static_if, который работает на gcc, можно сделать это:)
в ограниченном количестве

(см. также здесь)

Этот трюк включает специфическую интерпретацию GCC спецификаций на Lambdas в С++ 11. Таким образом, он (скорее всего) станет отчет о дефектах против стандарта. Это приведет к тому, что трюк больше не работает в более поздней версии GCC (он уже не работает в версии 4.7).

См. комментарий ниже для получения более подробной информации от Johanness

http://ideone.com/KytVv:

#include <iostream>

namespace detail {
template<bool C>
struct call_if { template<typename F> void operator<<(F) { } };

template<>
struct call_if<true> {
  template<typename F>
  void operator<<(F f) { f(); }
};
}

#define static_if(cond) detail::call_if<cond>() << [&]

template<bool C, typename T>
void f(T t) {
  static_if(C) {
    t.foo();
  };
}

int main() {
  f<false>(42);
}

Ответ 2

Почему бы не сделать реализацию отправки политикой класса отправителя и использовать CRTP:

template<class Derived>
class SingleSenderPolicy
{
    public:
    template< class memFunc >
    void callWrapperImpl(memFunc f, ...)
    {
        static_cast<Derived *>(this)->f(...);
    }
};

template< class Derived >
class DoubleSenderPolicy
{
    public:
    template< class memFunc >
    void callWrapperImpl(memFunc f, ...)
    {
        static_cast<Derived *>(this)->f(...);
        static_cast<Derived *>(this)->f(...);
     }
};

template< class SendPolicy>
class Sender : public SendPolicy< Sender >
{
public:
    void sendMessage( ... )
    {
       // call the policy to do the sending, passing in a member function that
       // acutally performs the action
       callWrapperImpl( &Sender::sendMessageImpl, ... );
    }

    void doSomethingElse( ... )
    {
       callWrapperImpl( &Sender::doSomethingElseImpl, ... );
    }


protected:
    void sendMessageImpl(... )
    {
        // Do the sending here
    } 

    void doSomethingElseImpl(... )
    {
        // Do the sending here
    } 
};

Общественный sendXXX функционирует в вашем классе, просто пересылает оболочку вызова, передавая в функцию-член, которая реализует реальную функциональность. Эта функция-член будет вызываться в соответствии с SendPolicy класса. CRTP сохраняет использование привязки для переноса аргументов и этого указателя с помощью функции-члена для вызова.

С помощью одной функции он действительно не сокращает количество кода, но если у вас много вызовов, это может помочь.

Примечание. Этот код является скелетом, чтобы обеспечить возможное решение, оно не было скомпилировано.

Примечание: Sender<DoubleSenderPolicy> и Sender<SingleSenderPolicy> являются совершенно разными типами и не разделяют динамические отношения наследования.

Ответ 3

Большинство компиляторов делают постоянную фальцовку и удаление мертвого кода, поэтому, если вы пишете регулярный оператор if:

enum SenderType { Single, Double };
template<SenderType T>
class Sender
{
   void sendMessage(...)
   {
      // do stuff
      if ( T == Single )
      {
         sendMessage(...);
      }
   }
};

Отключенная ветка if будет удалена при генерации кода.

Необходимость static if заключается в том, что инструкции будут вызывать ошибку компилятора. Поэтому скажите, что у вас есть что-то вроде этого (его несколько psuedo-код):

static if (it == random_access_iterator)
{
    it += n;
}

Поскольку вы не можете вызвать += для итераторов неслучайного доступа, тогда код всегда будет не скомпилирован с помощью регулярного оператора if, даже с удалением мертвого кода. Поскольку компилятор по-прежнему будет проверять синтаксис перед удалением кода. При использовании static if компилятор пропустит проверку синтаксиса, если условие не соответствует действительности.

Ответ 4

std::string a("hello world");
// bool a = true;
if(std::is_same<std::string, decltype(a)>::value) {
    std::string &la = *(std::string*)&a;
    std::cout << "std::string " << la.c_str() << std::endl;
} else {
    bool &la = *(bool*)&a;
    std::cout << "other type" << std::endl;
}