шаблон raii замены указателя на фукнцию

[Mayor]

шаблон raii замены указателя на фукнцию

допустим имеется набор указателей на функции разных типов и существует потребность временно, локально подменять функцию в указателе:

pf old=set_pf(&new_func);
// может случиться stack unwind
set_pf(old); // должна по любому выполниться перед выходом из функции

чтобы не писать raii класса для каждого типа фукнции и каждой фукнции подменяющей указаетель, как передать в шаблон фукнцию устанавлиювающую новый указатель и тип указателя?

[Finch]

Mayor, А зачем это надо? На настояшем проекте за такие финты сразу бы выгнали, без дополнительных объяснений. Слишком опасный код. Что мешает пользователю вызвать функцию не стеми аргументами?

[Mayor]

как это не с теми аргументами?

аргументом функции будет тот же указатель на фукнцию, аргументом шаблона тоже наверное будет установочная фукнция

насчет того, опасный не опасный, выгнали не выгнали - зависит от лида проекта, если не умеют пользоваться шаблонами, то естественно предпочитают брать тех кто не умеет пользоваться шаблонами - это можно проследить по тестовым задачкам перед собеседованием или по требованиям:

если в коде отсутвии виртуального деструктора считается за ошибку - то нефиг туда с шаблонами лезть

если в требованиях указано - отсутсвие знания линукс, то нефиг упоминать что ты им пользовался

по сабжу, задачка учебная и спорить тут опасный - не опасный бесмысленно, пока не заценишь шаблон на конкретных примерах

[Finch]

Применяй тип void *,  Он все вытерпет. А вызовы переопределяй в функциях.

Код:

void set_pf(type1 func);
void set_pf(type2 func);
void set_pf(type3 func);

Также скачай в сети библиотеку Loki http://sourceforge.net/projects/loki-lib/ . Эта библиотека была написана Андреем Александреску  и хорошо разобрана в его книге. Там тшательно смотри, как он реализовал функторы.

[Mayor]

похоже мы друг друга не поняли:

Код:

#include <iostream>
using std::cin;
using std::cout;
using std::endl;
void glob(int i) { cout<<"in global "<<i<<endl; }
void loc(int i) { cout<<"in local "<<i<<endl; }
typedef void (*f1)(int);
f1 ff1=glob;
f1 set_ff1(f1 a) { 
	f1 b=ff1;
	ff1=a;
	return b;
}
class stc {
	f1 old;
	public:
	stc(f1 ff) { old=set_ff1(ff); }
	~stc() { set_ff1(old); }
};
struct err {};
void test() throw (err) try {
	f1 a=set_ff1(loc);
	ff1(3);
	cout<<"in test"<<endl;
	int i=0;
	cin>>i;
	if (i>4) throw err();
	ff1(i);
	set_ff1(a);
}
catch(err ) {
	cout<<"catcha "<<endl;
}
void test1() throw (err) try {
	stc l(loc);
	ff1(3);
	cout<<"in test1 "<<endl;
	int i=0;
	cin>>i;
	if (i>4) throw err();
	ff1(i);
}
catch(err ) {
	cout<<"catcha test1 "<<endl;
}
/* лажа с передачей адреса фукнции в параметре
template<class T> class stct {
	T old;
	public:
	stct(T ff,T (*fff)(T)) { old=fff(ff); }
	~stct() { set_(old); }
};
void test2() throw (err) try {
	//stc l(loc);
	stct<ff1> l(loc,set_ff1);
	ff1(3);
	cout<<"in test1 "<<endl;
	int i=0;
	cin>>i;
	if (i>4) throw err();
	ff1(i);
}
catch(err ) {
	cout<<"catcha test1 "<<endl;
}
*/
int main() {
	ff1(1);
	//test();
	test1();
	cout<<"hello"<<endl;
	ff1(4);
}

в коде тест ведет себя не правильно - тк при выходе из нее есть вероятность, что измененный ей глобальный указатель не вернется к прежнему значению
test1 работает правильно - через raii class stc полюбому происходит востановление глобального указателя
сейчас у меня не получается написать шаблон, который можно будет вставить в test1,test2 и тд : в параметрах которого передается устанавливающая фукнция и тип указателя  на фукнцию, а в аргуметах конструктора - сам указатель

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


1h later:

удалось переписать шаблон, так чтобы он скомпилировался:

Код:

template<class T,T(*getval)(T)> class stct {
	T old;
	public:
	stct(T ff) throw() { 
		old=getval(ff);
       	}
	~stct() throw() { 
		getval(old);
	}
};
void test2() throw (err) try {
	stct<f1,set_ff1> l(loc1);
	ff1(3);
	cout<<"in test2 "<<endl;
	int i=0;
	cin>>i;
	if (i>4) throw err();
	ff1(i);
}
catch(err ) {
	cout<<"catcha test2 "<<endl;
}

вроде бы даже правильно работает, только как и говорил финч во 2м посте, все выглядит криво и непонятно ...

зы как-нибудь можно превратить вызов stct<f1,set_ff1> l(loc1) в    stct<set_ff1> l(loc1) ?
или дополнительное указание типа аргумента\возвращаемого значения из фукнции создает защиту "от дурака" ?

[Вад]

Хотелось бы прояснить одну вещь. А что здесь названо RAII? Я не вижу никакого ресурса. Ведь функцию сложно назвать отдельным выделяемым ресурсом?

[Mayor]

Хотелось бы прояснить одну вещь. А что здесь названо RAII? Я не вижу никакого ресурса. Ведь функцию сложно назвать отдельным выделяемым ресурсом?

указатель на фукнцию, по сути такой же ресурс, точно также захватывается, инициализируется и по окончании работы с ним нуждается в освобождении - только последствия нарушения высвобождения могут быть намного печальнее, чем утечка памяти

Mayor, А зачем это надо? На настояшем проекте за такие финты сразу бы выгнали, без дополнительных объяснений. Слишком опасный код. Что мешает пользователю вызвать функцию не стеми аргументами?

итак, независимо от того как ты пишешь на с++, у нас есть глобаные указатели на фукнцию, пусть это будут: callback, event handle, иже с ними - которые являются неотъемлимой частью библиотеки инициализирующей с++ приложение ... и возможно у некоторых со временем будет возникать необходимость насоздавать новых глобальных указателей - но это уже тема отдельного разговора

естественно, такие указатели приходится инкапсулировать в фукнцию, чтобы была возможность отследить или залогить каждое изменение указателя, и если речь не идет о системе конечных автоматов или терминации программы без возвращения из текущей функции - то, как правило, требуется востановить значение указателя

что мы имеем: проверку компилятором типа указателя при его подмене, те ни о каком вызове фукнции не с тем типом параметров не может быть и речи, тк без явного приведения типа  такой код просто не скомпилится

так что, остаются 3 беды:
- вызов фукнции подмены не с тем указателем
- вызов не той фукнции подмены
- внесение глобальных изменений в указатель при срабатывании исключения

зы с первыми 2мя ничего не сделать, тут все зависит от криворукости кодера, ему в принципе без разницы где накосячить:
function_type old_pf=set_function(new_pointer);
// или
raii_function_set<function_type,set_function> h(new_pointer);

зыы может быть это опять назовут антипатерном, но я при текущем уровне знаний, все равно не пойму почему

[Вад]

Теперь я понял. Только это не raii. Вот если бы у тебя контролировалось время жизни функции - это было бы raii. Скажем, в конструкторе загружалась бы dll-библиотека с функцией, а в деструкторе выгружалась бы. А раз ты никак не контролируешь время жизни ресурса - это не raii.

Я бы назвал это динамической настройкой диспетчеризации. Только непонятно, зачем указатель на функцию тогда инкапсулировать в объект. Если только - действительно, сопровождать доступ к функции какими-то сторонними эффектами типа записи логов.

[Finch]

Mayor, Я все равно не понимаю, для чего тебе  эти финты нужны. Причины:
1) Нарушается сама идеология классов. Вдруг они начинают регулировать глобальные переменные. При этом они не имеют полного контроля над переменной.
2) Раз подменяеш свою функцию локально, почему бы ее локально и не использовать напрямую?
3) Твой пример в многопоточном приложении сразу поплывет.

В контекста, того что сказал Вад, насчет временного хранения Dll. Это мне кажется вполне логично. Но в его примере всё будет хранится локально, в самом классе.

[Mayor]

Finch, 2 локально я вызывал фукнции только для тестирования, через глобальный указатель по идее фукнции будут вызываться из неизвестного участка кода

Вад, указатель инкапсулируется на случай проброса исключения

[Антон (LogRus)]

Mayor, а теперь дружно думаем о многопоточном коде

[sss]

LogRus, я честно признаюсь, перечитал раза 4 и ничего не понял. Что надо автору темы? Перехватить исключение и вернуть старое значение? Зачем тогда такой огород?

[Алексей++]

sss, автор темы "понимал толк в извращениях" (с)  )))

[Антон (LogRus)]

sss, я тоже ничего не понял, но в большинстве случаев подобные манипуляции над глобальными данными влекут неопределённое поведение в много поточном коде (если конечно нет какого-нибуть глобального мьютекса, который будет захвачен на всё время выполнения функции изменившей глобальные данные)

[sss]

Может быть это попытка динамически окружить любую устанавливаемую функцию дополнительным обработчиком? Но тогда лучше это делать в том месте, где вызывается переустанавливаемая  функция.  Это всё задачи объекта вызывающего CALLBACK.

[Mayor]

sss, эээ если ты подразумеваешь под переустанавливаемой функцией glob,loc -то вызываться она может и из сторонней библиотеки

[Антон (LogRus)]

и снова шум
не умеешь пользоваться русским, пользуйся кодом, ИМХО проще понять твой код, чем твой смысловой шум с непонятным подтекстом.

[lapulya]

А чем стратегия не подходит?

[Антон (LogRus)]

lapulya, отличный вопрос
давай конкретней обрисуй ситуацию и продолжим диспут

[lapulya]

LogRus, немного не понял кому ты предложил конкретнее обрисовать ситуацию мне или топикстартеру. Если мне, то я спрашивал о паттерне стратегия.

[Антон (LogRus)]

lapulya, вопрос к тебе , как именно ты предлагаешь использовать стратегии для конкретной задачи?

[lapulya]

так... давайте прежде чем будем структурировать определился правильно ли я все понимаю...

Mayor, я правильно понимаю, что следующий шаблон, который есть упрощенный твой шаблон (при условии, что set_ff1 одна и не меняется)

Код:

template<class T> class stct
{
	T old;
public:
	stct(T ff) throw()
	{ 
		old=set_ff1(ff);
    }
	~stct() throw()
	{ 
		set_ff1(old);
	}
};

void test2() throw (err)
{
	try
	{
		stct<f1> l(loc);
		ff1(3);
		cout<<"in test2 "<<endl;

		int i=0;
		cin>>i;

		if (i>4) throw err();
		ff1(i);
	}
	catch(err )
	{
		cout<<"catcha test2 "<<endl;
	}
}

,

это то, что тебе надо?

Если да, то ща бум структурировать, но для начала вопрос, зачем это надо? Какая прикладная задача решается? 

[lapulya]

собственно вопрос такой, что в данном случае является клиентом main или test2?
Если делать клиентом test2 эээ, то не ясна цель, поскольку test2 точно знает, что надо вызвать loc! Может его вызвать на прямую, стало быть клиент main, правильно?

[lapulya]

если нужны разные функции замены (set_ff1), то можно так

Код:

typedef void (*f1)(int);
typedef f1 (*f11)(f1);

template<class T> class stct
{
	T old;
	f11 change;
public:
	stct(T ff, f11 _change) throw()
	{
		change = _change;
		old=change(ff);
    }
	~stct() throw()
	{ 
		change(old);
	}
};

void test2() throw (err)
{
	try
	{
		stct<f1> l(loc, set_ff1);

...

[Антон (LogRus)]

lapulya, так, а где стратегии?

я пока вижу только стратегию синхронизации, как вариант развития

[lapulya]

LogRus, Я пока уточняю проблематику и для предложения верного варианта архитектурного решения, надо знать, что есть клиент. Возможно стратегия и не покатит (надо понять, например, функция подмены указателя одна или их несколько разных, вообще я хотел обернуть в стратегию функции передаваемые по указателю)

[Mayor]

ну если вспомнить с чего все началось:

1 нашел я где то упоминание\описание raii, честно говоря, я во всех этих синглетонах, фабриках, виртуальных конструкторах ни бум-бум - начал изобретать велосипед: те реализовывать raii в том плане как я понял из его описания

2 для чего потребовался какой-то объект-ресурс, чтобы проверить работоспособность кода на практике, и первое что пришло мне тогда в голову - глобальный указатель на глобальную функцию

3 первый попавшийся мне указатель был тогда _unexpected_handler, а установочная функция set_unexpected, но работать напрямую с ними я тогда не рискнул

а сейчас вообще не знаю, зачем этот raii вообще нужен

[lapulya]

Mayor, Эээээ т.е. реальной прикладной задачи нет? Вот ты тогда замутил... ты бы формулировал вопрос нипа нах нужен такой-то паттерн и ответ получит бы в первом же посте (или RTFM, ну или рассказали бы )

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

Все просто.

В прочем гарды бывают разные, могут использоваться не для охраны, а например, для гарантии освобождения ресурса (конструктор - открываем файл, деструктор - закрываем и т.д.)

[Mayor]

тут тоже самое и получилось:

запоминаем значение указателя в конструкторе и перезаписываем его
восстанавливаем значение указателя в деструкторе

в принципе работает при структурном подходе, единственное, что тк не умею работать с шаблонами - написано криво

а при ООП начинаются траблы: если делать через встроенный объект, то каллбек перехватится до того как создан объект, если создавать его в конструкторе, то при исключении в нем старое значение указателя не восстановится

что требовалось: узнать как передать тип устанавливающей функции и указателя через аргументы конструктора, а не шаблона

[lapulya]

Mayor, Тип через аргумент передать нельзя

Если хочешь вариант решения проблем, то проблему надо до нас донести, пока ты доносишь до нас свое решение нечта (это нечто мне лично пока не понятно) и говоришь, что оно тебя не устраивает. На основании этих данных помочь тебе очень сложно \

Я так понимаю, что мой вариант (последний или предпоследний), твою проблему не решил или решил?