Прямой эфир

0
функцию член класса(методов в С++ таки нет)
Гм, а что такое тогда метод?
  • avatar
  • Vga
  • 09 декабря 2015, 23:03
0
Забавная идея.
#define do_iteration(b) \
    static int _concate(__internal_var, __LINE__) = 0; \
    if (_concate(__internal_var, __LINE__) < b) if (++_concate(__internal_var, __LINE__)) 

Еще можно реализовать по аналогии с only_once:
#define do_iterations(a) \
    static int _concate(__internal_var, __LINE__) = a; \
    if (_concate(__internal_var, __LINE__)) if (_concate(__internal_var, __LINE__)--)
  • avatar
  • Vga
  • 09 декабря 2015, 22:55
0
Добрый день! Спасибо за лекции.
Жаль нету слайдов
  • avatar
  • ae999
  • 09 декабря 2015, 22:24
0
В языке не так уж много операторов. Этот был как-то ближе всего.
  • avatar
  • Mirmik
  • 09 декабря 2015, 22:06
0
Ох… Непривычная организация форума. Виноват.
  • avatar
  • Mirmik
  • 09 декабря 2015, 22:04
0
 что в правой части использовать auto
Упс, естественно в левой части выражения…
  • avatar
  • e_mc2
  • 09 декабря 2015, 22:01
0
Мне кажетеся Вы меня путаете с коллегой neiver и вопрос адресован ему?

У меня нет идей как упростить синтаксис, насколько я понимаю С++ не сможет автоматически вывести типы шаблона на основании сигнатуры функции. Поэтому, можно разве что в правой части использовать auto для сокращения синтаксиса. Хотя возможно я ошибаюсь, я больше пишу на С# (там выведение типов для обобщений работает немного по другому), С++ я, увы, стал постепенно забывать.
  • avatar
  • e_mc2
  • 09 декабря 2015, 21:59
0
Еще такой момент: сугубо имхо, но идея перегрузки оператора != для sigslot — не самая лучшая, ибо ломается привычная логика — оператор неравенства используется для добавления. Интуитивно понять, что выражение
somevar != foo();

добавляет функцию в список вызова (а не выполняет проверку) невозможно.

В отличии от перегрузки += -=, использование которых мне кажется интуитивно понятным (хотя возможно мне это кажется понятным из-за знания С#)
  • avatar
  • e_mc2
  • 09 декабря 2015, 21:48
0
А вы не пробовали как-нибудь упростить синтаксис…
Неплохо, пока параметр 1.

Но, всё-таки…
delegate2<void, int, float, double, double> d3 = delegate2<void, int, float, double, double>::Method<A, &A::task3>(&a);
Это не гуд.
  • avatar
  • Mirmik
  • 09 декабря 2015, 21:41
+2
Не стоит путать холодное с мягким. Делегаты решают проблемы человека живущего в с++. Иначе говоря, делегаты ради с++, а не с++ ради делегатов. Это не какой-то страшно крутой функционал, а некий аналог callback для классов.
  • avatar
  • Mirmik
  • 09 декабря 2015, 21:10
0
Ничего не потеряли. А некоторые (например, Линус Торвальдс) наоборот скажут, что Вы только выиграли реализовав таймеры на С :) С таким же успехом можно спросить: а что я потеряю реализовав таймеры с обратным вызовом на ASM? Просто разные парадигмы… В С для обратного вызова достаточно знать адрес функции (ну и желательно сигнатуру :), поэтому там смысла в таких обертках нет.
  • avatar
  • e_mc2
  • 09 декабря 2015, 20:59
0
Хочется понять, много ли я потерял, реализовав эти же таймеры на C, используя callback на голые функции.
  • avatar
  • amaora
  • 09 декабря 2015, 20:19
0
Хм… Согласен. Попробую это адаптировать.
  • avatar
  • Mirmik
  • 09 декабря 2015, 20:17
+1
Одно дело вызывать функцию по обычному указателю на функцию, и совсем другое вызывать функцию член класса(методов в С++ таки нет) по указателю на нее.
У меня в функцию-обёртку InvokeObj указатель на функцию член класса передается как параметр шаблона и известен на этапе компановки. В худшем случае такой вызов будет обычным вызовом по известному адресу, в лучшем — вызов вообще заинлайнится.
  • avatar
  • neiver
  • 09 декабря 2015, 20:11
0
amaora
Построение универсального интерфейса без применения наследования.
По сути мы оборачиваем объект и метод любого типа в обертку делегата. Дальше мы можем работать просто с делегатом, не особо задумываясь о многообразии типов.

Пример — класс таймеров. Функционал — запуск функций и методов через некоторое время после запуска таймера.
Мы хотим создать универсальный класс, чтобы он мог работать с любыми классами и функциями. В частности, мы не можем позволить себе решить эту проблему наследованием от некоего класса Timered. Это неэстетично. Чтобы создать универсальный таймер необходимо нечто, что поможет его работать с объектами разных типов. То есть, делегат.

Что касается сигналов, это тоже средство, позволяющее уменьшить связность программы. Вместо того, чтобы прописывать в классах какие-то левые взаимосвязи, мы объявляем сигнал и позволяем любым сторонним классам к нему присоединиться.
  • avatar
  • Mirmik
  • 09 декабря 2015, 20:08
0
Удобный механизм для передачи экземплярчик методов (и не тольео) в качестве функции обратного вызова.
  • avatar
  • e_mc2
  • 09 декабря 2015, 19:55
0
e_mc2
3. Вызов функции члена класса по указателю не очень эффективен, порядка 15-30 тактов если без параметров.
Так вы же тоже вызываете метод по указателю на метод 0_о… Или я что-то недопонял понял.<br /

1. Делегат инициализированный по умолчанию нельзя вызавать — будет доступ по нулевому указателю. Лучше по умолчанию инициализировать делегат пустой функцией, тогда и необходимость проверки отпадет.
Да и фиг с ним, честно говорю… Но, это да, пожалуй надоработка.

  • avatar
  • Mirmik
  • 09 декабря 2015, 19:53
0
А зачем это надо, никто не расскажет?
  • avatar
  • amaora
  • 09 декабря 2015, 19:47
+2
Я тоже использую подобные делегаты. Несколько рекомендаций:
1. Делегат инициализированный по умолчанию нельзя вызавать — будет доступ по нулевому указателю. Лучше по умолчанию инициализировать делегат пустой функцией, тогда и необходимость проверки отпадет.
2. Нет способа проверить, что делегат пустой и его нельзя вызывать.
3. Вызов функции члена класса по указателю не очень эффективен, порядка 15-30 тактов если без параметров.
4. Чтобы вызвать такой делегат из старого Си-шного кода (а иногда такое надо), придется вручную делать фукнцию обертку.

Есть способ лучше:
#include <iostream>
template<class Result>
class Delegate
{
public:
	typedef Result (*InvokeT)(void *);		// указатель на функцию (Invoke())
	static  Result VoidFunc() { return Result(); }
private:
	void *_object;
	InvokeT _callback;
	template<class ObjectT, Result (ObjectT::* Func)()>
	static Result InvokeObj(void *object){
		return (static_cast<ObjectT*>(object)->* Func)();
	}
	template<Result (* Func)()>
	static Result InvokeFunc(void *){
		return Func();
	}
	Delegate(void *obj, InvokeT func)
		: _object(obj), _callback(func) { }
public:

	Delegate()
		: _object(0), _callback(&InvokeFunc<VoidFunc>)	{ }
	// вызывает конструктор, 
	// для каждой функции класса создаёт свой Invoke (т.к. специализация шаблона!)
	// и передаёт указатель на Invoke как второй параметр ctor"а.
	template<class ObjectT, Result (ObjectT::* Func)()> static Delegate Make(ObjectT * object){
		return Delegate(object, &InvokeObj<ObjectT, Func>);
	}
	template<Result (* Func)()> static Delegate MakeFree(){
		return Delegate(0, &InvokeFunc<Func>);
	}
	// вызов Invoke и передача ему объекта для которого он был создан
	inline Result operator()()const{
		return _callback(_object);
	}
	InvokeT ToCFunction()const{
		return _callback;
	}
	void* Object()const{
		return _object;
	}
};

class Foo
{
public:
	bool Bar(){ std::cout << "Hello" << std::endl; return true;}
};

int main()
{
	Foo foo;
	Delegate<bool> d;
	d();
	d = Delegate<bool>::Make<Foo, &Foo::Bar>(&foo);
	d();
	return 0;
}
  • avatar
  • neiver
  • 09 декабря 2015, 19:17
0
не только экземпляр метод но статический, простую функцию, лямбду.
Упс, что-то я протормозил, это реализованно.
  • avatar
  • e_mc2
  • 09 декабря 2015, 19:05