[C++] throw() na functie/constructor declaratie??

[^Mo^]

Hoi,

Ik zat net eens in een COM header file te kijken (bij _bstr_t) en daar stond o.a. het volgende:

code:

_bstr_t() throw();

Wat is dit precies voor een syntax, heb ik nog nooit gezien .. hoe zou je dat moeten gebruiken? En als er niet een speciaal gebruik is, wat is dan de toegevoegde waarde?

'k heb wel een beetje Google gebruikt, maar ik weet niet goed waar ik naar moet zoeken om een zinnig resultaat te krijgen (sowwy)

[.oisyn]

dat wil zeggen dat die functie geen exceptie gooit

de compiler kan dan aan de hand van dat gegeven bepaalde dingen optimisen, omdat hij weet dat er geen exception gegooid zal worden

[hufkes]

geen exceptie throwt?

Ik ging even kijken in de msdn, en zag dit staan

code:

Microsoft Specific 

_bstr_t( ) throw( );

_bstr_t( const _bstr_t& s1 ) throw( );

_bstr_t( const char* s2 ) throw( _com_error );

_bstr_t( const wchar_t* s3 ) throw( _com_error );

_bstr_t( const _variant_t& var ) throw ( _com_error );

_bstr_t( BSTR bstr, bool fCopy ) throw ( _com_error );

Dan zou je juist zeggen dat hij toch wel een heleboel error's juist wel kan throwen Ikke niet snap

[^Mo^]

Op donderdag 06 juni 2002 17:13 schreef .oisyn het volgende:
dat wil zeggen dat die functie geen exceptie gooit

de compiler kan dan aan de hand van dat gegeven bepaalde dingen optimisen, omdat hij weet dat er geen exception gegooid zal worden

Er wordt juist wel een exception gegooid... of is het juist dat

code:

_bstr_t() throw();

geen exception gooit en een statement als

code:

_bstr_t(const char* s) throw(_com_error);

weer wel?
Dus eigenlijk komt het gewoon neer op 'good practice' dan?

-Edit-
Het is eigenlijk 'kan gooien'

[.oisyn]

alle types (en derived types) tussen de haakjes kunnen worden gegooid
Als er dus niets tussen de haakjes staat kan er ook niets worden gegooid (kan wel, maar dan wordt unexpected () aangeroepen en bla bla bla, moet je zelf maar even kijken in de link die ik nu ga geven )

zie ook punt 15.4 van de ANSI C++ draft

[^Mo^]

Eigenlijk wel grappig, de _bstr_t class is microsoft specific, als ik het goed begrijp uit de MSDN. En daar gebruiken ze dus deze syntax. Maar in de MSDN staat ook:

Microsoft Specific ?>

Microsoft C++ does not support the function exception specification mechanism, as described in section 15.4 of the ANSI C++ draft.

END Microsoft Specific

Vandaar dat ik ook niet echt begreep wat het nut was, aangezien het gewoon wordt genegeerd.
'k had een test functie gemaakt:

code:

void DoTest() const throw( int);

Maar ik kan gewoon een string gooien. Als ik het goed begrijp zou dit volgens de ANSI standaard dus niet kunnen..?

[.oisyn]

lol
ik wist wel dat ms het niet ondersteunde, daarom vond ik het ook een beetje vaag dat het in een COM object was gedefinieerd...

maar dat _bstr_t ook MS is en dat ze dan die syntax gebruiken is natuurlijk


.edit:

code:

void DoTest() const throw( int);

Maar ik kan gewoon een string gooien. Als ik het goed begrijp zou dit volgens de ANSI standaard dus niet kunnen..?

compilet dat dan?
volgens mij krijg ik een syntax error als ik het door de compiler gooi...
als het wel compilet is het natuurlijk wel logisch dat ze de throw syntax gebruiken, zij het voor future support (fat chance ), of voor andere compilers die het wel ondersteunen

.edit2: je hebt gelijk, het compilet idd wel gewoon...
wat probeerde ik dan laatst dat niet werkte maar wel correct was volgens de standaard

.edit3: oh ja een try-catch clause voor base en member constructors:

code:

Klasse::Klasse () try : membervar (4)
{
    ...
}
catch (exception e)
{
}

dat compilet dus niet in MSVC6

[^Mo^]

Op donderdag 06 juni 2002 17:33 schreef .oisyn het volgende:

code:

Klasse::Klasse () try : membervar (4)
{
    ...
}
catch (exception e)
{
}

dat compilet dus niet in MSVC6

Wist niet eens dat zo iets ooit zou kunnen.
Ik had het dan als volgt gedaan:

code:

Klasse::Klasse()
{
    try
    {
      membervar = 4;
    }
    catch( exception &e)
    {
    }
}

Heeft de ANSI methode een duidelijk voordeel of is het dan een kwestie van stijl?

[.oisyn]

probeer dat maar eens als membervar een klasse is

bijvoorbeeld:

code:

class Blaat
{
public:
    Blaat (int i);
};

class Klasse
{
public:
    Blaat membervar;

    Klasse ();
};

// normale initialisatie zou zo moeten:
Klasse::Klasse () : membervar (4)
{
}

// want dit is fout:
Klasse::Klasse ()
{
    membervar = 4;
}

// dus als je de exception wilt afvangen:
Klasse::Klasse () try : membervar (4)
{
}
catch (exception e)
{
}

verhaaltje geldt natuurlijk ook als het geen member variabele betreft maar een superclass

[^Mo^]

gelijk heb je Helemaal niet aan gedacht..