Cute C++ idioms Nikhil Marathe.

Transcription

1 Cute C++ idioms Nikhil Marathe

2 Everybody knows 10% of C++

3 Qt style No exceptions Return values indicate errors Well defined memory models Qt tree based ownership, occasional ref counting Gecko optional tree based ownership, pervasive ref counting, cycle collector magic. Widespread use of RAII and templates

4 RAII Resource Acquisition Is Initialization (The God Pattern)

5 Stack allocated C++ objects Void Foo() ClassA a; ClassB b; // More code... Int main() Foo(); A's constructor runs B's constructor runs. Code runs When Foo() exit's Destructor of b runs. Then destructor of a runs.

6 Various situations require undo void LaunchMissile(Target* atarget) Missile* missile = new Missile(); if (!atarget) return; What went wrong? if (atarget->isfriendly()) return; missile->fire(); delete missile;

7 Various situations require undo void LaunchMissile(Target* atarget) Missile* missile = new Missile(); if (!atarget) return; if (atarget->isfriendly()) return; What went wrong? If any early return is hit, the missile will leak memory! missile->fire(); delete missile;

8 Various situations require undo void LaunchMissile(Target* atarget) Missile* missile = new Missile(); if (!atarget) delete missile; return; Improved code if (atarget->isfriendly()) delete missile; return; missile->fire(); delete missile;

9 Various situations require undo void LaunchMissile(Target* atarget) Missile missile; if (!atarget) return; We can do better! if (atarget->isfriendly()) return; missile.fire();

10 A more relevant example void SynchronizedAction(Mutex* amutex) amutex->lock(); If (mcountdown == 0) return; Ack! Forgot to unlock mutex on return. mcountdown--; amutex->unlock();

11 RAII C++ has well defined construction and destruction ordering for variables declared on the stack. Analogous to a toggling action: Constructor will set up some behaviour Destructor will undo the behaviour

12 RAII class RAIIDemo public: RAIIDemo(Resource* aresource) aresource->init(); ; ~RAIIDemo() aresource->uninit(); ; Void Foo(Resource* aresource) RAIIDemo raii(aresource); if (FalseCondition()) return; If (ThingsWentReallyWrong()) throw new Exception(); aresource->domagic(); The resource is ALWAYS cleanly uninitialized.

13 Uses Synchronization primitives class AutoMutexLock public: AutoMutexLock(Mutex* amutex) amutex->lock(); ; ~AutoMutexLock() amutex->unlock(); ;

14 Uses Toggle preferences class AutoErrorReporter JSErrorReporter* moldreporter; public: AutoErrorReporter(JSErrorReporter* areporter) moldreporter = JS_GetReporter(); JS_SetReporter(aReporter); ; ~AutoMutexLock() JS_SetReporter(mOldReporter); ;

15 Smart Pointers Various RAII classes that act like pointers, but improve their safety. Auto pointers - QScopedPointer Reference counting pointers - QSharedPointer Weak pointers QWeakPointer Also QPointer, which avoids dangling.

16 Auto pointers Take ownership of a heap allocated object Release it on destruction Act like a pointer to the rest of the code Prevents leaks and dangling pointers An application of RAII std::unique_ptr (C++11), QScopedPointer, nsautoptr

17 Sample AutoPointer template <class T> class AutoPtr T* mrawptr; Void assign(t* arawptr) T* old = mrawptr; mrawptr = arawptr; delete old; AutoPtr<T>& operator=(t* arawptr) assign(arawptr); return *this; AutoPtr<T>& operator=(nsautoptr<t>& rhs) assign(rhs.forget()); return *this; Public: AutoPtr() : mrawptr(nullptr) AutoPtr(T* arawptr) : mrawptr(arawptr) AutoPtr(const AutoPtr<T>& aother) : mrawptr(aother.forget())

18 Let's add some pointer behaviour // Allow DoFoo(ptr) where DoFoo(T* ptr) operator T*() const return mrawptr; // Allow ptr->operation() T* operator->() const assert(mrawptr); // crash on null return mrawptr; // Allow *ptr T& operator*() const assert(mrawptr); return *mrawptr; T* forget() T* temp = mrawptr; mrawptr = nullptr; return temp; This class is incomplete, but let's ignore that for now :)* * Mainly no equality operator.

19 Now go crazy! Void DoFoo() AutoPtr<Foo> ptr(new Foo()); ptr->method(); std::out << *ptr; AutoPtr<Foo> takeownership(ptr); // ptr is now null! // If we want to transfer ownership to someone else. BarTender *b = new BarTender(); b->setfoo(takeownership.forget());

20 Assertions Crash early, crash often. Usually only enabled in debug mode. Better than... leaking, dangling, accidentally accessing memory. Eases debugging tremendously!

21 Assertions in Qt Q_ASSERT() and Q_ASSERT_X() void expectsvalidobject(qobject* aobject) Q_ASSERT(aObject); // more code expectsvalidobject(nullptr); // Will crash!

22 Q_ASSERT_X allows conditional testing. Q_ASSERT_X(mHours < 10, mmeal == Breakfast); Q_ASSERT_X(mHours < 14, mmeal == Lunch);

23 Understanding the event loop All UI toolkits have an event loop to deal with user interaction and proceed in a logical manner. Typically, each QApplication will have it's own event loop. Modal dialogs have their own event loop. All activity happens due to events being dispatched from the OS to the event loop and objects responding to them.

24 Simple event loop Queue<QEvent*> events; QEvent* currentevent = nullptr; while (true) if (events.isempty()) waitforevents(); currentevent = events.dequeue(); application->event(currentevent);

25 Qt's memory model Parent-child relationship When a parent is deleted, it deletes all it's children. When a child is deleted, it does NOT delete it's parent! Qt practice is to always create UI elements on the heap and parent them properly to avoid leaks. Qt uses this model to also draw things on screen.

26 Cleaning up objects Sometimes you want to keep object lifetime in your control. Use deletelater() for UI objects Can be connected to signals too. Preferably use the smart pointer classes. When returning new objects from functions, document lifetimes and ownership!