void
    MyClass::HashMapSample(void)
    {
        HashMap map(SingleObjectDeleter);

        // Constructs a %HashMap instance with default capacity, load factor, hash code provider, and comparer
        map.Construct();

        map.Add(new String(L"Zero"), new Integer(0));       // map.GetCount() : 1, map : (Zero -> 0)
        map.Add(new String(L"One"), new Integer(1));        // map.GetCount() : 2, map : (Zero -> 0), (one -> 1)
        map.Add(new String(L"Two"), new Integer(2));        // map.GetCount() : 3, map : (Zero -> 0), (one -> 1), (Two -> 2)

        // Gets a value with the specified key
        Integer*    pValue = static_cast< Integer* > (map.GetValue(String(L"Zero")));       // pValue : 0

        // Removes the value with the specified key
        map.Remove(String(L"Zero"));                                            // map.GetCount() : 2, map : (one -> 1), (Two -> 2)

        // Uses an enumerator to access elements in the list
        IMapEnumerator* pMapEnum = map.GetMapEnumeratorN();
        String* pKey = null;
        while (pMapEnum->MoveNext() == E_SUCCESS)
        {
            pKey = static_cast< String* > (pMapEnum->GetKey());
            pValue = static_cast< Integer* > (pMapEnum->GetValue());
        }

        delete pMapEnum;

        // Deallocates all objects
        // Because the destructor calls RemoveAll() internally, you don't need to call RemoveAll() to destroy all elements at the end.
        map.RemoveAll();

    }

map.Destruct();

The object is not fully constructed after this constructor is called. For full construction,
the Construct() method must be called right after calling this constructor.

Error handling in Tizen works differently compared to standard C++. Tizen uses error results instead of C++ exceptions, due to historical reasons.

Q: Why does Tizen use two-phase construction?

A: Tizen does not use the C++ exception mechanism. This reduces its footprint and runtime overhead. As a result, any exception occurring in C++ object construction cannot be reported to the application.

Furthermore, when a failure occurs in allocating resources during an object's construction, the object is partially constructed and its destructor is not called, possibly causing a resource leak. To resolve these problems, Tizen uses the two-phase construction idiom for many classes where exceptions must be reported to Tizen native applications. For more information, see Two-phase Construction.
Q: What happens if I do not call a Construct() method?

A: Some methods throw an exception, and some return a probably meaningless value. In any case, Tizen does not guarantee the reliability or consistency of user applications. You must make sure that the Construct()method is invoked properly before an instance of a two-phase construction class is used.

Out-of-memory Exception

Almost all APIs, except simple getter methods, can potentially throw an E_OUT_OF_MEMORY exception, although the APIs do not specify the out-of-memory (OOM) exception.
...

if (GetLastResult() == E_OUT_OF_MEMORY)

L>Да двухфазная инициализация — это жесть. Получается, что тебе дали объект, но сказать, можно ли его использовать, забыли. Особенно забавно на этом фоне выглядят конструкторы копирования

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

IMapEnumerator* pMapEnum = map.GetMapEnumeratorN();
delete pMapEnum;

struct Object
{
    virtual ~Object() {}
};
struct Integer: Object
{
    int value;
    Integer(int val) : value(val){}    
};
int main()
{
    Object * o = new Integer(10);
    Integer * i = static_cast<Integer *>(o);
}

J>int main()
J>{
J>    Object * o = new Integer(10);
J>    Integer * i = static_cast<Integer *>(o);
J>}
J>

The C++ built-in static_cast can be used for efficiently downcasting pointers to polymorphic objects, but provides no error detection for the case where the pointer being cast actually points to the wrong derived class. The polymorphic_downcast template retains the efficiency of static_cast for non-debug compilations, but for debug compilations adds safety via an assert() that a dynamic_cast succeeds.

My typical reply is also somewhere along the same lines: if you don't like to use exceptions, then just don't use them. Leave that job to the professionals

static void call()
{
    Holder h0;
    exceptions<iter-1>::call(); // may throw

    Holder h1;
    exceptions<iter-1>::call(); // may throw
    // ...
}

static bool call()
{
    bool result = true;
    void *d0;
    void *d1;
    // ...

    d0 = mallocator();
    if(! (result=ifgoto<iter-1>::call()) ) // may fail
        goto ERROR0;

    d1 = mallocator();
    if(! (result=ifgoto<iter-1>::call()) ) // may fail
        goto ERROR1;
    // ...

    // ...
    ERROR1: free(d1);
    ERROR0: free(d0);

    return result;
}

#include <boost/range/algorithm/nth_element.hpp>
#include <boost/preprocessor/arithmetic/sub.hpp>
#include <boost/preprocessor/repeat.hpp>
#include <boost/preprocessor/cat.hpp>
#include <boost/noncopyable.hpp>
#include <boost/timer/timer.hpp>
//#include <boost/timer.hpp>

#include <iostream>
#include <ostream>
#include <cstdlib>
#include <vector>
#include <ctime>

using namespace std;
using namespace boost;

// ______________________________ //

const int series = 33;
const int deepness = 5;
#define REPEATS 32

// ______________________________ //

bool error_check()
{
    //return time(0) < 1;
    static volatile bool t = false;
    return t;
}
void *mallocator()
{
    return malloc(4);
}

// ______________________________ //

class Holder : private noncopyable
{
    void *data;
public:
    Holder()
        : data(mallocator())
    {}
    ~Holder()
    {
        free(data);
    }
};
template<int iter> struct exceptions
{
    static void call()
    {
        #define EXP_REP(z, i, _) Holder h##i; exceptions<iter-1>::call();
            BOOST_PP_REPEAT(REPEATS,EXP_REP,t)
    }
};
template<> struct exceptions<0>
{
    static void call()
    {
        if(error_check()) throw false;
    }
};

// ______________________________ //

template<int iter> struct ifgoto
{
    static bool call()
    {
        bool result = true;

        #define IFG_REP0(z, i, _) void *d##i;
            BOOST_PP_REPEAT(REPEATS,IFG_REP0,t)

        #define IFG_REP1(z, i, _) d##i = mallocator(); if(! (result=ifgoto<iter-1>::call()) ) goto ERROR##i;
            BOOST_PP_REPEAT(REPEATS,IFG_REP1,t)

        #define IFG_REP_AUX(i) BOOST_PP_CAT(ERROR,i): free(BOOST_PP_CAT(d,i));
        #define IFG_REP2(z, i, _) IFG_REP_AUX( BOOST_PP_SUB(BOOST_PP_SUB(REPEATS,1),i) )
            BOOST_PP_REPEAT(REPEATS,IFG_REP2,t)

        return result;
    }
};
template<> struct ifgoto<0>
{
    static bool call()
    {
        return error_check() == false;
    }
};

// ______________________________ //

template<template<int> class test_case>
void test(const char *name)
{
    cout << name;
    vector<double> times;
    for(int i=0;i!=series;++i)
    {
        //timer t;
        timer::cpu_timer t;
        test_case<deepness>::call();
        times.push_back(double(t.elapsed().user));
    }
    vector<double>::iterator median = times.begin() + times.size()/2;
    nth_element(times,median);
    cout << "\tmedian is " << (*median)*1e-6 << "ms" << endl;
}

int main()
{
    try
    {
        for(int i=0;i!=2;++i)
        {
            test<exceptions>("exceptions");
            test<ifgoto>("if-error-goto");
        }
    }
    catch(...){}
}

exceptions      median is 1731.61ms
if-error-goto   median is 1762.81ms
exceptions      median is 1731.61ms
if-error-goto   median is 1747.21ms

exceptions      median is 1326.01ms
if-error-goto   median is 1716.01ms
exceptions      median is 1326.01ms
if-error-goto   median is 1716.01ms

mt@mint14 ~/Desktop $ g++ exceptions.cpp -O3
mt@mint14 ~/Desktop $ time ./a.out

real 0m53.612s
user 0m49.559s
sys 0m0.028s
mt@mint14 ~/Desktop $ gcc error_code.c -O3 -std=c99
mt@mint14 ~/Desktop $ time ./a.out

real 0m53.730s
user 0m49.647s
sys 0m0.024s

const int MAX_COUNT = 100000000;

char buf;
int count = 0;

void open()
{
    if (++count == MAX_COUNT)
    {
        count = 0;
        throw 1;
    }
}

void read(char* c)
{
    *c = buf;
    if (++count == MAX_COUNT)
    {
        count = 0;
        throw 1;
    }
}

void send(char* c)
{
    buf = *c;
    if (++count == MAX_COUNT)
    {
        count = 0;
        throw 1;
    }
}

int main()
{
    for (int i = 0; i != 1000; ++i)
    {
        try
        {
            open();
            char c;
            for (int j = 0; j != MAX_COUNT + 1; ++j)
            {
                read(&c);
                send(&c);
            }
        }
        catch (const int&)
        {
        }
    }
}

#define MAX_COUNT 100000000

char buf;
int count = 0;

int open()
{
    if (++count == MAX_COUNT)
    {
        count = 0;
        return -1;
    }
    return 0;
}

int read(char* c)
{
    *c = buf;
    if (++count == MAX_COUNT)
    {
        count = 0;
        return -1;
    }
    return 0;
}

int send(char* c)
{
    buf = *c;
    if (++count == MAX_COUNT)
    {
        count = 0;
        return -1;
    }
    return 0;
}

int main()
{
    for (int i = 0; i != 1000; ++i)
    {
        if (open() == -1)
            continue;
        char c;
        for (int j = 0; j != MAX_COUNT + 1; ++j)
        {
            if (read(&c) == -1)
                break;
            if (send(&c) == -1)
                break;
        }
    }
}

map.Add(new String(L"Zero"), new Integer(0));
map.Add(new String(L"One"), new Integer(1));
map.Add(new String(L"Two"), new Integer(2));

IMapEnumerator* pMapEnum = map.GetMapEnumeratorN();
delete pMapEnum;

map.Add(new String(L"Two"), new Integer(2));     

String*    pValue = static_cast< String* > (map.GetValue(String(L"Zero"))); 

pValue->length(); // тут все плохо...

Ну вот собственно я и прошу (тех, кто уверен что исключения — это всегда лучше) показать подходящий юзкейс правильного использования, когда оно улучшило архитектуру или уменьшило объём кода. Потом хочу прикинуть как бы я это сделал без исключений и сравнить объём/читаемость...

ASErr EmptyPanelPlugin::StartupPlugin(SPInterfaceMessage *message)
{
    AIErr err = kNoErr;
    
    // Call base class routine
    err = Plugin::StartupPlugin(message);
    if (err)
        return err;

    AINotifierHandle appShutDownNotifier;
    err = sAINotifier->AddNotifier(fPluginRef, "AI Application Shutdown Notifier", kAIApplicationShutdownNotifier, &appShutDownNotifier);
    if(err)
        return err;
    
    AIErr error = kNoErr;

    // Add About Plugins menu item for this plug-in.
    SDKAboutPluginsHelper aboutPluginsHelper;
    error = aboutPluginsHelper.AddAboutPluginsMenuItem(message, 
                kSDKDefAboutSDKCompanyPluginsGroupName, 
                ai::UnicodeString(kSDKDefAboutSDKCompanyPluginsGroupNameString), 
                "EmptyPanel...", 
                &fAboutPluginMenu);

    if (error)
        return error;

    // Add menu item
    error = sAIMenu->AddMenuItemZString(fPluginRef, "Third Party Panel", kOtherPalettesMenuGroup, ZREF("Third Party Panel"),
                                        kMenuItemNoOptions, &fEmptyPanelPanelMenuItemHandle);
    if (error)
        return error;

    fPanelFlyoutMenu = NULL;
    error = sAIPanelFlyoutMenu->Create(fPanelFlyoutMenu);
    if (error)
        return error;

    error = sAIPanelFlyoutMenu->AppendItem(fPanelFlyoutMenu, 1, ai::UnicodeString("First Item"));
    error = sAIPanelFlyoutMenu->AppendItem(fPanelFlyoutMenu, 3, ai::UnicodeString("Third Item"));
    error = sAIPanelFlyoutMenu->InsertItem(fPanelFlyoutMenu, 3, 2, ai::UnicodeString("Second Item"));
    error = sAIPanelFlyoutMenu->InsertSeparator(fPanelFlyoutMenu, 3, 5);
    error = sAIPanelFlyoutMenu->AppendItem(fPanelFlyoutMenu, 4, ai::UnicodeString("Fourth Item"));

    error = sAIPanelFlyoutMenu->SetItemEnabled(fPanelFlyoutMenu, 4, false);
    error = sAIPanelFlyoutMenu->SetItemMark(fPanelFlyoutMenu, 1 , kAIPanelFlyoutMenuItemMark_BULLET);
    error = sAIPanelFlyoutMenu->SetItemMark(fPanelFlyoutMenu, 2 , kAIPanelFlyoutMenuItemMark_CHECK);
    error = sAIPanelFlyoutMenu->SetItemMark(fPanelFlyoutMenu, 3 , kAIPanelFlyoutMenuItemMark_DASH);

    AISize pnSize = {240, 320};
    error = sAIPanel->Create(fPluginRef, ai::UnicodeString("Third Party Panel"), ai::UnicodeString("Third Party Panel"), 3, pnSize, true, fPanelFlyoutMenu, this, fPanel);
    if (error)
        return error;

    AISize minSize = {50, 50};
    AISize maxSize = {800, 800};
    AISize prefConstSize = {100, 100};
    AISize prefUnconstSize = {600, 600};

    error = sAIPanel->SetSizes(fPanel, minSize, prefUnconstSize, prefConstSize, maxSize);

    error = sAIPanel->Show(fPanel, true);
    error = sAIPanel->SetFlyoutMenuPreVisibilityProc(fPanel, flyoutMenuPreVisFunc);
    error = sAIPanel->SetFlyoutMenuProc(fPanel, PanelFlyoutMenuProc);
    error = sAIPanel->SetVisibilityChangedNotifyProc(fPanel, PanelVisibilityChangedNotifyProc);
    error = sAIPanel->SetSizeChangedNotifyProc(fPanel, PanelSizeChangedNotifyProc);
    error = sAIPanel->SetStateChangedNotifyProc(fPanel, PanelStateChangedNotifyProc);
    error = sAIPanel->SetClosedNotifyProc(fPanel, PanelClosedNotifyProc);

    error = SetIcon();

    error = AddWidgets();
    
    //Add Menu Item for Control Bar
    if(!error)
        error = sAIMenu->AddMenuItemZString(fPluginRef, "Third Party Control Bar", kOtherPalettesMenuGroup, ZREF("Third Party Control Bar"),
                                            kMenuItemNoOptions, &fEmptyPanelControlBarMenuItemHandle);
    
    //Create Control Bar
    AISize sizeControlBar = {controlBarWidth, controlBarHeight};
    if(!error)
        error = sAIControlBar->Create(fPluginRef, sizeControlBar, controlBarWidthMin, controlBarWidthMax,NULL/*Userdata*/,fControlBar);
    if(!error)
        error = sAIControlBar->SetUserData(fControlBar, this);
    
    //Set Callbacks
    if(!error)
        error = sAIControlBar->SetVisibilityChangedNotifyProc(fControlBar, ControlBarVisibilityChangedNotifyProc);
    if(!error)
        error = sAIControlBar->SetSizeChangedNotifyProc(fControlBar, ControlBarSizeChangedNotifyProc);
    
    //Add Different Widgets to Control Bar
    if(!error)
        AddWidgetsToControlBar();
    
    return error;
}

error = sAIPanel->Show(fPanel, true);
error = sAIPanel->SetFlyoutMenuPreVisibilityProc(fPanel, flyoutMenuPreVisFunc);
error = sAIPanel->SetFlyoutMenuProc(fPanel, PanelFlyoutMenuProc);
error = sAIPanel->SetVisibilityChangedNotifyProc(fPanel, PanelVisibilityChangedNotifyProc);
error = sAIPanel->SetSizeChangedNotifyProc(fPanel, PanelSizeChangedNotifyProc);
error = sAIPanel->SetStateChangedNotifyProc(fPanel, PanelStateChangedNotifyProc);
error = sAIPanel->SetClosedNotifyProc(fPanel, PanelClosedNotifyProc);

sAIPanel->Show(fPanel, true);
sAIPanel->SetFlyoutMenuPreVisibilityProc(fPanel, flyoutMenuPreVisFunc);
sAIPanel->SetFlyoutMenuProc(fPanel, PanelFlyoutMenuProc);
sAIPanel->SetVisibilityChangedNotifyProc(fPanel, PanelVisibilityChangedNotifyProc);
sAIPanel->SetSizeChangedNotifyProc(fPanel, PanelSizeChangedNotifyProc);
sAIPanel->SetStateChangedNotifyProc(fPanel, PanelStateChangedNotifyProc);
error = sAIPanel->SetClosedNotifyProc(fPanel, PanelClosedNotifyProc);

The availability of exceptions may encourage developers to throw them when they are not appropriate or recover from them when it's not safe to do so. For example, invalid user input should not cause exceptions to be thrown. We would need to make the style guide even longer to document these restrictions!

On their face, the benefits of using exceptions outweigh the costs, especially in new projects. However, for existing code, the introduction of exceptions has implications on all dependent code. If exceptions can be propagated beyond a new project, it also becomes problematic to integrate the new project into existing exception-free code. Because most existing C++ code at Google is not prepared to deal with exceptions, it is comparatively difficult to adopt new code that generates exceptions.

Никто не заставляет использовать исключения для каждого вида ошибок, а тем более для return values.

{
    vector<int> v(16); // may fail on allocation
    cout << v[0];
}

EP>>{
EP>>    vector<int> v(16); // may fail on allocation
EP>>    cout << v[0];
EP>>}
EP>>

struct MyStruct
{
    vector<int> v;
    // ...
    MyStruct()
        : v(16)
    {}
};
// ...
{
    MyStruct m;
}

class Percent
{
    double p;
public:
    explicit Percent(double p_)
        : p(p_)
    {
        if( (p > 100.0) || (p<0.0) )
            throw domain_error("Wrong Percent");
    }
    double value() const
    {
        return p;
    }
};
// ...
{
    Percent p(user_input_from_upper_layers);
}

result     HashMap::Construct (const IMap &map, float loadFactor=0.75)

Tizen::Base::Object::Object (const Object &obj) [protected]
//This is the copy constructor for the Object class.

EP>result     HashMap::Construct (const IMap &map, float loadFactor=0.75)
EP>

Copying of objects using this copy constructor is allowed.

A& A::operator=(A rhs) // временный объект (т.к. по значению)
{
  swap( rhs );         // коммит (nothrow)
  return this;
}