цель c — Что такое C ++ эквивалент шаблона делегата obj-c?

Question

цель c — Что такое C ++ эквивалент шаблона делегата obj-c?

Я довольно хорошо знаком с obj-c, и теперь я пытаюсь глубже изучить C ++.

Я ищу C ++ эквивалент для шаблона делегирования obj-c.

1

Решение

Другие решения

На самом деле нет эквивалента 1: 1. Objective C является несколько динамически типизированным языком. protocol в Obj-C это как обещание, что функции («селекторы») с определенными сигнатурами будут существовать во время выполнения. Ты не иметь реализовать их, если вы не хотите, но вы должны, если вы не хотите, чтобы что-то зависало во время выполнения, если только они не помечены @optional,

C ++ для сравнения на 100% статически типизирован. Если вы говорите какую-то функцию должен существует, то это имеет существовать, иначе программа не скомпилируется. Если суперкласс объявляет функцию как абстрактную, то подклассы должен унаследовать это. Множественное наследование (которое необходимо, если вы хотите, чтобы класс реализовывал несколько разобщенных протоколов) — это минное поле.

Преимущество статической типизации (C ++) состоит в том, что вы можете знать во время компиляции, является ли ваша программа функционально завершенной (есть ли код для каждого места, где должен быть код). Однако цена этого заключается в том, что иногда вам приходится придумывать другие решения для заполнения протоколов и делегирования Obj-C.

1

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

Здесь много кода, но интерфейс довольно чистый. Что пользователь должен сделать, это просто маленький код внизу. Есть еще некоторый шаблон, связанный с конструкторами, но это исчезнет в будущем с синтаксисом «наследующих конструкторов» C ++ 11.

/* Class to be used as a member of the delegation host.
Keeps a list of event clients, which you can iterate over.
As a C++11 convenience, function call operator() is overloaded to call
all clients with the given argument list.

This is templated over the base type for the clients. The base type
should define virtual function(s) for handling the events.
Templating is necessary because we can't anticipate the number or types
of these virtual functions. */

template< typename delegate >
struct delegator {
typedef std::list< delegate * > list; // host interface
list delegates;

typedef typename list::iterator delegate_id; // client interface

delegate_id add( delegate *d )
{ return delegates.insert( delegates.end(), d ); }

void remove( delegate_id d )
{ delegates.erase( d ); }

#if __cplusplus >= 201103L // C++11-only convenient host interface
template< typename ... args >
void operator() ( args && ... a ) {
for ( auto d : delegates ) ( *d )( std::forward< args >( a ) ... );
}
#endif
};

/* Abstract base class for all delegate bases. Registers and unregisters
from the delegator, but doesn't define any event handler. */
template< typename derived >
struct delegate {
typedef ::delegator< derived > delegator;

delegator &source;
typename delegator::delegate_id id;

delegate( delegator &in_source )
: source( in_source ),
id( source.add( static_cast< derived * >( this ) ) ) {}

virtual ~delegate() { source.remove( id ); }
};

/* Example delegate base. Defines an event handler which clients must implement.
Other types of events might declare other bases. */
struct my_delegate_base : delegate< my_delegate_base > {
typedef delegate< my_delegate_base > base;
typedef base::delegator delegator;
my_delegate_base( delegator &d ) : base( d ) {}

virtual void operator() ( int ) = 0;
};

/* Example client class defines how to handle an event. */
struct my_delegate_impl : my_delegate_base {
my_delegate_impl( delegator &d ) : my_delegate_base( d ) {}

virtual void operator() ( int i ) {
std::cout << i << '\n';
}
};

Посмотрите, как это работает: https://ideone.com/IRp5rJ

0

Источник

Accepted Answer

Вместо того, чтобы соответствовать протоколу, вы просто наследуете класс (протокол).
Небольшой пример:

class Delegate
{
public:
// Some pure virtual method here.
virtual void method() = 0;
};

class A : Delegate
{
void method() { // Do something here... };
};

class B
{
Delegate your_delegate;
// Somewhere in your code you might need to call the method() using: your_delegate.method();
};

4