один блок catch для нескольких операторов new? - C/C++

Доброго времени суток всем! Не подскажет ли, уважаемое сообщество, как оптимизировать такой код:

int ff(const Proto<type1>& s)
{
try
{
new Cclass1(s);
}
catch(std::bad_alloc)
{
return 1;
}

return 0;
}
// ...
// еще несколько реализаций функции ff
// ...
int ff(const Proto<type2>& s)
{
try
{
new Cclass2(s);
}
catch(std::bad_alloc)
{
return 1;
}

return 0;
}

возможно ли обойтись одним блоком catch для всех операторов new?

Здравствуйте, Аноним, Вы писали:

А>возможно ли обойтись одним блоком catch для всех операторов new?
Может лучше ловить исключения в функции вызывающей ff?
Или пользоваться так:

int ff(const Proto<type1>& s)
{
  return new(nothrow) Cclass1(s) ? 0 : 1;
}

Здравствуйте, GregZ, Вы писали:

GZ>Здравствуйте, Аноним, Вы писали:

А>>возможно ли обойтись одним блоком catch для всех операторов new?
GZ>Может лучше ловить исключения в функции вызывающей ff?

вызовы функции ff находятся в разных местах, поэтому получится то же самое — на каждый вызов свой catch

GZ>Или пользоваться так:

GZ>

GZ>int ff(const Proto<type1>& s)
GZ>{
GZ>  return new(nothrow) Cclass1(s) ? 0 : 1;
GZ>}
GZ>

интересный вариант

Здравствуйте, <Аноним>, Вы писали:

А>Доброго времени суток всем! Не подскажет ли, уважаемое сообщество, как оптимизировать такой код:

А>возможно ли обойтись одним блоком catch для всех операторов new?

Если я Вас правильно понял, то вот Вам пример:

inline int handle_exception()
{
    bool result = false;

    try
    {
        throw;
    }
     catch(std::bad_alloc&)
    {
         return 1;
    }
    catch(...)
    {
        return -1;
    }
}


int ff(int i)
{
    try
    {
        throw std::bad_alloc();
    }
    catch(...)
    {
        return handle_exception();
    }

    return 0;
}

int ff(const char* s)
{
    try
    {
            throw std::bad_alloc();
    }
    catch(...)
    {
        return handle_exception();
    }

    return 0;
}


int _tmain(int argc, _TCHAR* argv[])
{
    std::cout << ff(12) << std::endl;
    std::cout << ff("adsad") << std::endl;
}

По сути, это не моё, подробности смотреть здесь Полезная вещь, наверное а первоисточник Re: подход к try-catch

На самом деле можно и дальше навернуть, при желании и осмыслении.

ЗЫ если я не так понял что такое

обойтись одним блоком catch для всех операторов new

Просьба — не пинать

Да, ещё, в Вашем примере отлов исключений производился не по ссылке ( вероятно опечатка)

... << RSDN@Home 1.1.4 stable rev. 510>>

Здравствуйте, Аноним, Вы писали:

Еще можешь так:

Все ff заменяешь на:

int ff(const Proto<type1>& s)
{
  new Cclass1(s);
}

а вызываешь эту функцию:

template <class T>
int ff_wrapper(const Proto<T>& s)
{
  try
  {
    ff(s);
  }
  catch(std::bad_alloc)
  {
    return 1;
  }
}

Здравствуйте, srggal, Вы писали:

S>Здравствуйте, <Аноним>, Вы писали:

А>>Доброго времени суток всем! Не подскажет ли, уважаемое сообщество, как оптимизировать такой код:

Все, понял в чем вопрос:


template< typename UnaryFunction >
    int construct( UnaryFunction func, typename UnaryFunction::argument_type arg )
    {
        try
        {
            return func( arg );
        catch(std::bad_alloc&)
        {
            return 1;
        }
        catch(...)
        {
            return -1;
        }
    }
    
int _tmain(int argc, _TCHAR* argv[])
{
    std::cout << construct( std::ptr_fun<int, int>( ff ), 12 ) << std::endl;
    std::cout << construct( std::ptr_fun<const char*, int>( ff ), "12" ) << std::endl;
}

раньше уже написали Re[3]: один блок catch для нескольких операторов new?, но зато у меня универсальней

... << RSDN@Home 1.1.4 stable rev. 510>>

Здравствуйте, <Аноним>, Вы писали:

А>возможно ли обойтись одним блоком catch для всех операторов new?
Бритвой Оккама его по горлу:

// вариант 1
template <class T>
struct my_traits;

template <>
struct my_traits<type1> {
    typedef Class1 type;
}
template <>
struct my_traits<type2> {
    typedef Class2 type;
}
template <class T>
int ff(const Proto<T>& s) {
    try {
      typedef typename my_traits<T>::type AssociatedClass;
      AssociatedClass* c = new AssociatedClass(s);
    }
    catch(std::bad_alloc&) {
      return 1;
    }
    return 0;
}

// вариант 2
Class1* create(const Proto<type1>& s) {
  return new Class1(s);
}
Class2* create(const Proto<type2>& s) {
  return new Class2(s);
}
template <class T>
int ff(const Proto<T>& s) {
    try {        
      Base *b = create(s); 
    }
    catch(std::bad_alloc&) {
      return 1;
    }
    return 0;
}

... << RSDN@Home 1.1.4 stable SR1 rev. 568>>

Здравствуйте, srggal, Вы писали:

S>


S>template< typename UnaryFunction >
S>    int construct( UnaryFunction func, typename UnaryFunction::argument_type arg )
S>    {
S>        try
S>        {
S>            return func( arg );
S>        catch(std::bad_alloc&)
S>        {
S>            return 1;
S>        }
S>        catch(...)
S>        {
S>            return -1;
S>        }
S>    }
    
S>int _tmain(int argc, _TCHAR* argv[])
S>{
S>    std::cout << construct( std::ptr_fun<int, int>( ff ), 12 ) << std::endl;
S>    std::cout << construct( std::ptr_fun<const char*, int>( ff ), "12" ) << std::endl;
S>}
    
S>

воспроизвел это у себя — вроде, то что надо. Только я не совсем понимаю, что делает функция std::ptr_fun<..., ...>( ff ), ..., MSDN не помог (:.

Здравствуйте, <Аноним>, Вы писали:

А>Здравствуйте, srggal, Вы писали:

S>>


S>>template< typename UnaryFunction >
S>>    int construct( UnaryFunction func, typename UnaryFunction::argument_type arg )
S>>    {
S>>        try
S>>        {
S>>            return func( arg );
S>>        catch(std::bad_alloc&)
S>>        {
S>>            return 1;
S>>        }
S>>        catch(...)
S>>        {
S>>            return -1;
S>>        }
S>>    }
    
S>>int _tmain(int argc, _TCHAR* argv[])
S>>{
S>>    std::cout << construct( std::ptr_fun<int, int>( ff ), 12 ) << std::endl;
S>>    std::cout << construct( std::ptr_fun<const char*, int>( ff ), "12" ) << std::endl;
S>>}
    
S>>

А>воспроизвел это у себя — вроде, то что надо. Только я не совсем понимаю, что делает функция std::ptr_fun<..., ...>( ff ), ..., MSDN не помог (:.

Она делает из ваших ff полноцекнный unary_function (см. в доке по STL ), что позволяет в
construct получить тип аргумента.

int construct( UnaryFunction func, typename UnaryFunction::argument_type arg )

Явная параметризация шаблона ptr_fun нужна из-за того, что у вас перегруженные функции ff, если бы ff
была одна то:

[ccode]
std::cout << construct( std::ptr_fun( ff ), 12 ) << std::endl;
[ccode]

Подробности адапторы фунуторов хорошо описаны у Мейерсы в Эффективном использованиии СТЛ (название точно не помню)

... << RSDN@Home 1.1.4 stable rev. 510>>

Здравствуйте, srggal, Вы писали:

В догонку, если не делать unary_function, то тогда все станет намного неприглядней:

template< typename Func, typename Arg >
    int construct( Func func, Arg arg )
    {
        try
        {
            return func( arg );

        }
        catch(std::bad_alloc&)
        {
            return 1;
        }
        catch(...)
        {
            return -1;
        }
    }
    
int _tmain(int argc, _TCHAR* argv[])
{
    std::cout << construct<int(*)(int), int>( ff, 12 ) << std::endl;
    std::cout << construct<int(*)(const char*)>( ff, "12" ) << std::endl;
}

... << RSDN@Home 1.1.4 stable rev. 510>>

Здравствуйте, srggal, Вы писали:

И опять сам себе:

Можно и так:

template< typename Ret, typename Arg >
    int construct( Ret(*func)(Arg) , Arg arg )
    {
        try
        {
            return func( arg );
        }
        catch(std::bad_alloc&)
        {
            return 1;
        }
        catch(...)
        {
            return -1;
        }
    }
    
int _tmain(int argc, _TCHAR* argv[])
{
    std::cout << construct<int,int>( ff, 12 ) << std::endl;
    std::cout << construct<int, const char*>( ff, "12" ) << std::endl;
}

Но первоначальный вариант c unary_function — в духе СТЛ, и это позаволит ему использовать адаптерами и биндерами, и соответсвенно он является более обобщенным, поскольку в него можно без переделок засунуть и метод класса, и адаптированный binary_function....

... << RSDN@Home 1.1.4 stable rev. 510>>

	От:	Аноним
	Дата:	07.10.05 07:20
	Оценка:

	От:	GregZ
	Дата:	07.10.05 07:26
	Оценка:

	От:	Аноним
	Дата:	07.10.05 07:33
	Оценка:

	От:	srggal
	Дата:	07.10.05 07:39
	Оценка:

	От:	GregZ
	Дата:	07.10.05 07:50
	Оценка:

	От:	Глеб Алексеев
	Дата:	07.10.05 08:28
	Оценка: