value=default_value;
try
{
    value=f();
}
catch(exception)
{
}

value=default_value;
    f(&value);

void f()
{
    start_transaction();
    doit() ? commit_transaction() : rollback_transaction();
}

V>Начинаю обещанный топик Сознательно начинаю его именно в форуме по С++, т.к. хочу ограничить обсуждение именно этим языком (применительно к другим языкам, например к джаве, мое отношение к сабжу отличается с точности почти до наоборот

V>value=default_value;
V>try
V>{
V>    value=f();
V>}
V>catch(exception)
V>{
V>}
V>

V>value=default_value;
V>    f(&value);
V>

V>void f()
V>{
V>    start_transaction();
V>    doit() ? commit_transaction() : rollback_transaction();
V>}
V>

V>Т.о. появляется фактор "неожиданности", который мне лично очень претит и который у меня ассоциируется с оператором goto

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

V>В философии это будут общие слова ни о чем Типа: "и то и то имеет смысл в зависимости от ситуации" и с этим трудно не согласится. Я же говорю, очень много чего зависит от средства разработки.

V>Поему сложнее? Если пользователь библиотеки не удосужился обратить внимание на возможные возвращаеимые значение, он не удосужится и try/catch поставить. При этом прога сразу завалится, что сразу же наведет на некоторые размышления

V>Только для меня это нечто намного более редкое, чем для тебя

B>>При наличии этого assert'а (несколькими строчками выше кто говорил о возможности игнорирования кодов возврата... )

int nRetCode = someFunc();
assert(nRetCode != FAIL);

M>>Твое личное дело О вкусах не спорят.

if(OpenFile())
  if(MakeSomeString(str))
    if(WriteFile(str))
      CloseFile();
    else
      DoSomething();
  else
    DoSomethingElse();
else
  DoAnotherThihg();

try
  {
    OpenFile();
    MakeSomeString(str);
    WriteFile();
    CloseFile();
  }
catch(CFileExeption* ) {DoSomething();}
catch(COtherExeption*) {DoSomethingElse();}

M>>Не надо ненужность механизма обосновывать небрежностью (хотел вообще то другое слово использовать ) программиста.

V>Стройности ей придаст обилие try/catch? Не смешно. Разбираться в проге с эксепшинами наоборот сложнее, т.к. не видно явно откуда и куда можно попасть. Почти как goto, только еще хуже goto не умеет между функциями скакать.

V>>>Только для меня это нечто намного более редкое, чем для тебя

RetCode = someFunc1();
if(RetCode != GOOD)
   return RetCode;

...

RetCode = someFuncN();
if(RetCode != GOOD)
   return RetCode;

M>Не надо под "верхом" понимать MainFrame

M>if(OpenFile())
M>  if(MakeSomeString(str))
M>    if(WriteFile(str))
M>      CloseFile();
M>    else
M>      DoSomething();
M>  else
M>    DoSomethingElse();
M>else
M>  DoAnotherThihg();
M>

if (!OpenFile())
  DoAnotherThihg();
else
{
  if(!WriteFile(str))
      DoSomething();

  CloseFile();
}

try
{
  OpenFile();

  try
  {
    WriteFile();
  }
  catch(CFileExeption* ) 
  {
      DoSomething();
  }

  CloseFile();
}
catch(CFileExeption* ) 
{  
  DoAnotherThihg();
}

V>>Стройности ей придаст обилие try/catch? Не смешно. Разбираться в проге с эксепшинами наоборот сложнее, т.к. не видно явно откуда и куда можно попасть. Почти как goto, только еще хуже goto не умеет между функциями скакать.

M>try/catch у тебя будет один. Если же ты каждую функцию, которая кидает ексепшен вставляешь в отдельный try блок, то могу только принести свои соболезнования

M>Да что ты говоришь? Доказательства в студию, плиз

M>Смотри ответ на пример

V>if (!OpenFile())
V>  DoAnotherThihg();
V>else
V>{
V>  if(!WriteFile(str))
V>      DoSomething();

V>  CloseFile();
V>}
V>

V>try
V>{
V>  OpenFile();

V>  try
V>  {
V>    WriteFile();
V>  }
V>  catch(CFileExeption* ) 
V>  {
V>      DoSomething();
V>  }

V>  CloseFile();
V>}
V>catch(CFileExeption* ) 
V>{  
V>  DoAnotherThihg();
V>}
V>

try
{
   OpenFile();
   WriteFile();
   CloseFile();
}
catch(CFileException* e)
{
   if(e->m_cause == /* ошибка открытия */)
      DoAnotherThihg();
   else if(e->m_cause == /* ошибка чтения/записи */)
   {
      DoSomething();
   }
}

V>try
V>{
V>  OpenFile();

V>  try
V>  {
V>    WriteFile();
V>  }
V>  catch(CFileExeption* ) 
V>  {
V>      DoSomething();
V>  }

V>  CloseFile();
V>}
V>catch(CFileExeption* ) 
V>{  
V>  DoAnotherThihg();
V>}
V>

class File
{
  public:
  File(){}
  ~File(){ CloseFile(); }
  open(){ OpenFile(); }
  write( Param params ){}
};

//....//
File file;
try
{
  file.open();
  file.write( someParam );
}
catch(FileOpeningFailed&  )
{
  DoSomething();
}
catch(CFileWritingFailed&  )
{
  DoAnotherThihg();
}

//..
try
{
  if( RIGHT_VALUE != someVariable ) throw SomeException;
}
catch(SomeException&)
{
  someVariable = RIGHT_VALUE;
}
//..

bool success=true;
    try
    {
        f();
    }
    catch(exception)
    {
        success=false;
    }

    if (success)
    {
    ...
    }
    else
    {
    ...
    }

class SomeClass
{
  bool m_bInit;
public:
  SomeClass():m_bInit(false){}
  int init()
  {
    bool bRet = true;
    if( !bInit )
    {
      //Инициализация
      if( bProblem ) bRet = false;
    }
    return bRet;
  }

  bool someFunction()
  {
    if( !bInit ) return false;
    //..выполнить действия
    return true;
  }
};

try
{
   struct closer
   {
       closer(A &owner) : _a(owner) {}
       ~closer() { _a.CloseFile(); }
   private:
       A _a;
   };

   OpenFile();
   closer(*this);
   WriteFile();
}
catch(CFileException* e)
{
   if(e->m_cause == /* ошибка открытия */)
      DoAnotherThihg();
   else if(e->m_cause == /* ошибка чтения/записи */)
   {
      DoSomething();
   }
}

closer(*this);

closer somename(*this);

V>И "это" лучше if/else??? Вопросов больше не имею (с)

void Save()
{
  try
  {
    WriteLog("Save");
  }
  catch (...)
  {
  }
  string filename = "out.dat";
  try
  {
    filename = GetFileName();
  }
  catch (...)
  {
  }

  File file (filename);
  file.Write (data);
}

//А функция WriteLog выглядит как-нибудь так
void WriteLog(string s)
{
  File file ("log.dat"); //здесь 
  file.Write (s);        //или здесь может выскочить exception
}

//А функция GetFileName() берет название файла, например, из конфигурационного файла:
string GetFileName()
{
  File file ("config.dat"); //здесь опять же может выскочить exception
  return file.ReadLine();
}

void writeLog( const std::string& strLog )
{
  try
  {
    File file ("log.dat");
    file.Write (s);
  }
  catch(...)
  {
    // assertion для debug версии.
  }
}

class Data
{
  std::string getDataFileName()
  {
    std::string fileName = "out.dat";

    try
    {
      fileName = ... //получение имени файла
    }
    catch(...)
    {
      writeLog("Exception when trying to get file name for data");
      // assertion для debug версии.
    }
    return fileName
  }
public:
  void write( const Param& param )
  {
    File file( getDataFileName() )
    file.write( param );
  }
  Param param read()
  {
    File file( getDataFileName() )
    return file.read();
  }
}

void save()
{
  writeLog("Save");
  try
  {
    Data data;
    data.write();
  }
  catch(...)
  {
    writeLog("Exception in 'save' function");
  }
}

void load()
{
  writeLog("Load");
  try
  {
    Data data;
    data.read();
  }
  catch(...)
  {
    writeLog("Exception in 'load' function");
  }
}

int atoi (string s);

int atoi (string s) throw exception;

int atoi (string s, int default_value) throw exception
{
  try
  {
    return atoi (s);
  }
  catch (parse_error)
  {
    return default_value;
  }
}

void put_Value (string s)
{
  this.value = atoi (s, this.value);
 
}

void put_Value (string s)
{
  try
  {
    this.value = atoi(s);
  }
  catch (...)
  {
  }
}

void Init()
{
  this.value = atoi (LoadString(), 0);
}

int MyFunc()
{
  return atoi(GetValueFromFile();
}

string s;
try
{
  s = GetValueFromFile();
}
catch (...)
{
  try
  {
    s = GetValueFromRegistry();
  }
  catch (...)
  {
    s = GetValueFromUser();
  }
}
return atoi(s);

return atoi (or_call(GetValueFromFile(), GetValueFromRegistry(), GetValueFromUser()));

  return atoi (GetValueFromFile() ?? GetValueFromRegistry() ?? GetValueFromUser());

class X
{
public:
    X(){throw 0;}
};

class Y
{
X x;
};

class Y
{
    std::auto_ptr<X> x;
public:
    Y()
    {
        try
        {
            x.reset(new X);
        }
        catch (...)
        {
        }
    }
};

V>class Y
V>{
V>    std::auto_ptr<X> x;
V>public:
V>    Y()
V>    {
V>        try
V>        {
V>            x.reset(new X);
V>        }
V>        catch (...)
V>        {
V>        }
V>    }
V>};
V>

class Y
{
    std::auto_ptr<X> x;
public:
    Y() :
        x(new(nothrow) X)
    {
    }
};

f()
{
  preparing_to_print();
  before_print();
  about_to_print();
  pre_print();
  print();
  post_print();
  after_print();
}

void writeLogС(char* msg);

void writeLogСPP(const char* msg);

{
  writeLogC(const_cast<char*>(msg));
}

{
  char *tmp_buf = new char[strlen(msg)+1];
  strcpy(tmp_buf,msg);
  writeLogC(tmp_buf);
}

WC>void writeLogС(char* msg);
WC>

WC>void writeLogСPP(const char* msg);
WC>

void writeLogСPP(const std::string &msg);

B>>Если на то пошло, то MSVC6 тоже это не поддерживает

V>В смысле не поддерживает??? А я вовсю использовал такую декларацию Да и в MSDN'е тоже встречаются правильные прототипы.

Note   Microsoft C++ does not support exception-specifications, as described in section 15.4 of the ANSI C++ draft. In addition, it does not support function-try-block described in section 15 of the ANSI C++ draft.

J>В общем, давайте возьмемся за руки и все вместе пообещаем друг другу писать у своих функций exception specifications! (Хотя бы при помощи дефайнов )

template <class T>
int f()  // вот что здесь прописать???
{
    return T::f(); // неизвестно, какие исключения f может кидать. 
                   // мы должны пропустить их все или часть
}

J>>В общем, давайте возьмемся за руки и все вместе пообещаем друг другу писать у своих функций exception specifications! (Хотя бы при помощи дефайнов )

AVK>template <class T>
AVK>int f()  // вот что здесь прописать???
AVK>{
AVK>    return T::f(); // неизвестно, какие исключения f может кидать. 
AVK>                   // мы должны пропустить их все или часть
AVK>}
AVK>

AVK>Так что, в бесшаблонном коде спецификация исключений — благо, а в шаблонном — неясно, что делать.

template <class File, class FileException = File::exception_type>
int f() throw (FileException)
{
...
};