ich komme von C# und entwickle gerade meinen ersten ComServer mit C++ (ATL).
Ich wollte einen try{}catch{..} Block mit finally{} abschließen, was in C# gang und gebe ist.
Ich bekomme immer nur die Meldung:
"Fehler 1 error C2065: 'finally': nichtdeklarierter Bezeichner"

Wenn ich das finally Schlüsselwort eingebe, wird es vom VS Studio (bei mir) blau dargestellt. Gibt es finally gar nicht in C++? In der MSDN kann ich nichts brauchbares finden.

Gruß
camelord

So, wie ich das sehe, kannst du hier eigentlich einen Destruktor benutzen, da dieser auch im Falle einer Exception aufgrund des Rollback aufgerufen wird.

(Bin jetzt nicht 100% sicher, ob das äquivalent zu finally angesehen kann, aber auf den ersten Blick scheint es mir so..)

http://msdn.microsoft.com/en-us/library/yb3kz605(VS.80).aspx

Eigentlich ist es auch nicht notwendig und wichtig. Platziere den Code hinter den catch-Block, dann wird es auch immer ausgeführt

Das sehe ich nicht so. Natürlich geht es auch irgendwie anders, aber Exceptions sind ja gerade dazu da, daß man den Code zur Fehlerbehandlung klar strukturiert und übersichtlich schreiben kann.
Dein Vorschlag mit "hinter den catch-Block" macht nicht wirklich das selbe, z.B. wenn der catch-Block returned oder selbst wieder eine Exception wirft. Und genau um solche Fälle geht es ja bei finally.

Statements zum Umgang mit Exceptions kann man gar nicht genug haben, ich persönlich bin ja ein großer Fan von Python's try/except/else/finally

So mach ich es bisher:

try
{
::EnterCriticalSection(&m_csControllerMessgage);
//Codeblock
}
catch(...)
{
//bla bla
}
::LeaveCriticalSection(&m_csControllerMessgage);

In C# bin ich es eben gewohnt, solch ein Konstrukt mit finally abzuschließen.
Das obige Beispiel sieht irgendwie unschön aus.

Wie macht man sowas dann in C++?
Gruß
camelord

CCriticalSection m_csControllerMessage;
...
void CClass::MyFunc()
{
    CSingleLock lock(&m_csControllerMessage, TRUE);
    // tu was...
}// hier "automatisch" unlock

Das ware ein Beispiel für RAII.

EDIT: Da war jemand schneller...

try {
::EnterCriticalSection(&m_csResultStateMessgage);
try {
//Code
}
finally {
::LeaveCriticalSection(&m_csResultStateMessgage);
}
}
catch(...){
//bla blubb
}

get aber net..

So fänd ichs prima:

try {		
     ::EnterCriticalSection(&m_csResultStateMessgage);
     try {
           //Code
	 }
     finally {
	        ::LeaveCriticalSection(&m_csResultStateMessgage);
	     }
    }
catch(...){
            //bla blubb
          }

get aber net..

Mal abgesehn von der grausamen Klammersetzung die du durch die fehlenden cpp-Tags versteckt hast:

class CriticalSectionWrapper
{
  CCriticalSection& cs; //evtl. const, wenn möglich, Typ auch entsprechend Anpassen
public:
  CriticalSectionWrapper(CCriticalSection& cs_) //hier auch  
  : cs(cs_)
  {
    ::EnterCriticalSection(&cs);
  }
  ~CriticalSectionWrapper()
  {
    ::LeaveCriticalSection(&cs);
  } 
};

//.....

try 
{		
  CriticalSectionWrapper(m_csResultStateMessgage);
  //Code
}
catch(...)
{
  //bla blubb
}

Wenn //Code eine exception wirft wird der CriticalSectionWrapper beim Verlassendes try-Blocks zerstört und damit per DTor die Critical section wieder verlassen. Ganz klassischer Fall von RAII. Wenn du wie von R3dNeXX vorausgesetzt tatsächlich die MFC verwendest schau dir mal das von ihm genannte CSingleLock an.

CComAutoCriticalSection m_csResultStateMessage;
...
void CClass::MyFunc()
{
     try
     {       
          CComCritSecLock<CComAutoCriticalSection> lock(myCriticalSectionObject, true);
          //Code
     }
     catch(...)
     {
          //bla blubb
     }        
}

Kann ich das auch so schreiben:

Klar, zumindest wenn die Lock-Klasse nicht irgendeinen unerwarteten Nebeneffekt hat. Ansonsten ist das doch das Selbe wie in meinem Beispiel (mal abgesehn dass die Lock-Klasse ne andere ist)

Vielen dank für die flotte Hilfe!

Schönen Tag noch..