Overview. The Whited Sepulchre Four Strings to a Bow λ-connectedness

Size: px

Start display at page:

Download "Overview. The Whited Sepulchre Four Strings to a Bow λ-connectedness"

Karin Campbell
6 years ago
Views:

2 Overview The Whited Sepulchre Four Strings to a Bow λ-connectedness

3 The Whited Sepulchre QList Woe unto you, scribes and Pharisees, hypocrites! for ye are like unto whited sepulchres, which indeed appear beautiful outward, but are within full of dead men's bones, and of all uncleanness. (King-James' Bible, Matthew 23:27)

4 Arraylist-like (otherwise, ie. default) Indirections (bad) Vector-like (sizeof T sizeof void*, Q_MOVABLE_TYPE) No indirections (good)

5 QList<QVariant> Arraylist-like QList<QImage> QList<double> 32 bit QList<double> 64 bit Vector-like QList<int> QList<bool>

6 QList T i s i h C s + + n, t o, a v a J o n! # C t

7 QList Don't use QList Use QVector or std::vector instead If you need array-list functionality, use QVector<T*> or std::vector<t*> or, better, yet: std::vector<unique_ptr<t>> or QVector<QSharedPointer<T>> or...

8 QTypeInfo Mark your own types with Q_DECLARE_METATYPE(T, What) where What can be any of: Q_COMPLEX_TYPE (the default) Q_MOVABLE_TYPE (= trivially relocatable) Q_PRIMITIVE_TYPE (~ trivially copyable) Used by QList, QVector, QVariant,... Beware: In general, changing an existing type's classification is binary-incompatible!

9 Four (½) Strings to a Bow aka Hello World const char[12] C-string literal??? QString UTF-16

10 Four Strings to a Bow Which one is better? (1) func( Hello World ); (2) func(qstring::fromlatin1( Hello World )); (3) func(tr( Hello World )); (4) func(qlatin1string( Hello World )); (5) func(qstringliteral( Hello World ));

11 Four Strings to a Bow Which one is better? (1) QString s = Hello World ; (2) QString s = QString::fromLatin1( Hello World ); (3) QString s = tr( Hello World ); (4) QString s = QLatin1String( Hello World ); (5) QString s = QStringLiteral( Hello World );

12 Four Strings to a Bow Which one is better? (1) s += Hello World ; (2) s += QString::fromLatin1( Hello World ); (3) s += tr( Hello World ); (4) s += QLatin1String( Hello World ); (5) s += QStringLiteral( Hello World );

13 Four Strings to a Bow Which one is better? (1) s + Hello World ; (2) s + QString::fromLatin1( Hello World ); (3) s + tr( Hello World ); (4) s + QLatin1String( Hello World ); (5) s + QStringLiteral( Hello World );

14 What does better mean? Less to type? More readable? Better internationalisation (i18n)? Smaller executable code size? Less data in executable? Faster execution? Safer?

15 f( Hello World ) Implicit conversion from const char[] to QString Good readability, little to type Implemented (mostly) as QString::fromUtf8() Always allocates memory Expensive UTF-8 decoding even if source is ASCII Little code and data size (out-of-line function) Somewhat i18n-safe (can deal with Unicode) Disable with QT_NO_CAST_FROM_ASCII, QT_RESTRICTED_CAST_FROM_ASCII

16 s + Hello World Direct support in QStringBuilder Good readability, little to type Implemented as QString::fromUtf8() but with a US-ASCII fast-path May allocate memory Expensive UTF-8 decoding if source isn't US-ASCII Little code and data size (out-of-line function) Somewhat i18n-safe (can deal with Unicode) Disable with QT_NO_CAST_FROM_ASCII

17 f(fromlatin1( Hello World )) Explicit conversion from const char* to QString Poor readability, lots to type QString::fromLatin1() Always allocates memory Cheap latin-1 decoding (uchar -> ushort) Little code and data size (out-of-line function) Not i18n-safe (can't deal with Unicode) Avoid. same for: s + fromlatin1( Hello World )

18 f(tr( Hello World )) Explicit conversion from const char* to QString Good readability, little to type Implemented by hash lookup / fromutf8() Always allocates memory Expensive UTF-8 decoding even if source is ASCII Little code and data size (out-of-line function) Perfect for i18n (Unicode, supports localisation) Always use for user-visible strings, even if you plan no localisation.

19 s + tr( Hello World ) Anti-Pattern, don't use Use tr() + QString::arg() instead: Prevents translators from re-arranging sentence structure d/t different grammar of target language tr( File %1 saved).arg(filename) Strongly prefer multiarg over.arg() chaining: wrong: tr( %1 %2 %3).arg(v1).arg(v2).arg(v3) 3 temp QStrings created correct: tr( %1 %2 %3).arg(toString(v1), tostring(v2), tostring(v3));

20 f(qlatin1string( Hello World )) Explicit conversion from const char[] to QString Poor readability, lots to type Separate type, just stores pointer and length Never allocates memory No decoding at all Little code and data size (trivial constexpr inline function) No i18n (No unicode)

21 f(qlatin1string( Hello World )) Not all functions taking QString are overloaded on QLatin1String Still compiles (implicit conversion to QString) But always allocates memory Provide QLatin1String overloads of your QString functions if You have a faster / non-allocating implementation Never implement QLatin1String overloads via QString ones except during development & test

22 f(qlatin1string( Hello World )) Use always when passing (C-string) literals to functions overloaded on QLatin1String. QString::operator==/!= QString::starts/endsWith() QString::append/op+= QString::contains() (currently poorly impl'ed)

23 s + QLatin1String( Hello World ) QStringBuilder fast-path all inline never allocates memory Use always when passing (C-string) literals to QStringBuilder

24 f(qstringliteral( Hello World )) Explicit conversion of const char[] to UTF-16 Poor readability, lots to type Compile-time creation of a static-storageduration,.rodata QString::Data never allocates memory (at runtime) UTF-8 decoding performed at compile-time Larger code size (out-of-line QString dtor calls) Larger data size (stores UTF-16 + QString::Data header) Somewhat i18n-safe (supports Unicode)

25 QStringLiteral Implemented using lambda functions Every QStringLiteral is a separate entity No sharing of identical QStringLiterals across functions Also no sharing with equivalent C string literals Most definitely no sharing of common suffixes Falls back to fromutf8() on non-c++11 compilers (incl. MSVC < 2015). Potentially lots of duplicated identical string data Inherits all disadvantages of fromlatin1()/fromutf8() Capacity == Size Any non-const function will make a deep copy

26 s + QStringLiteral( Hello World ) Falls back to QString operation in QStringBuilder Size info is probably lost for most compilers Still out-of-line QString dtors cluttering the code Avoid. Strongly prefer QLatin1String. Option for non-latin1-string literals, though.

27 QStringLiteral Library unloading gotcha: QString copies originating from a QStringLiteral call in a shared library reference static-storageduration data in that library. If the library gets unloaded while there are still copies of the strings... R.I.P. Cf. Mechanisms based on dynamic memory don't have this problem

28 QStringLiteral Use only when: You use a fully conforming C++11 compiler on all your platforms! The function you're passing the C-string literal to doesn't overload on QLatin1String. The string coming from the QStringLiteral will not or not often or not soon have non-const functions called on it. The string will not be handed out of the shared library, if any. Also, if the string is actual Unicode.

29 QLatin1String Use when: You shouldn't use QStringLiteral (e.g. in C+98) The function you're passing the C-string literal to doesn't overload on QLatin1String incl. QStringBuilder The string coming from the QLatin1String will have non-const functions called on it. The string will be handed out of the shared library, if any.

30 General Guideline Prefer QString s = ; // QStringBuilder over QString s; s +=...; // reserves excess capacity s +=...; // probably free over QString s =...; // allocates, but capacity == size s +=...; // reallocates s +=...; // probably free

31 λ-connectedness

32 Qt 4 Signal/Slot Connections connect(sender, SIGNAL(...), receiver, SLOT(...)); #define SIGNAL(x) #x #define SLOT(x) #x String-based lookup

33 Qt 4 Signal/Slot Connections String-based lookup no compile-time checking very dynamic used e.g. in QtDesigner signature normalisation problems slow path when signatures used in SIGNAL/SLOT are not normalised typedefs and namespaces not really supported must use the same name everywhere, across all classes Prefer normalized signal/slot signatures Details: marcmutz.wordpress.com/effective-qt/prefer-to-usenormalised-signalslot-signatures/

34 Qt 5 Signal Connections connect(sender, &Sender::signalName,...); Passing member function pointers compile-time checked annoying when signals are overloaded ugly function-pointer cast needed subtle and hard-to-diagnose problems with duplicated functions Details: Volker Krause, Among ELFs and DWARFs, QtWS 2015 Prefer this form in new code Avoid overloading signals

35 Qt 5 Slot Connections - PMF connect(..., receiver, &Receiver::slot); Passing member function pointers compile-time checked can connect to slots with different arg types annoying when slots are overloaded annoying when slots have default arguments Prefer this form in new code warning: uses explicit constructors! for public slots Avoid overloading and default-arg'ing slots

36 Qt 5 Slot Connections - Λάμδα connect(..., [...](...){...}); Passing a lambda function (or function object) compile-time checked control expressed in fitting context less executable size compared to Qt 4 or PMF connects Λάμδα vs. Qt 4: PMF vs. Qt 4:

37 Qt 5 Slot Connections - Λάμδα Prefer this form in new code to replace private slots Avoid writing private slots they take up space in the QMetaObject are still accessible publicly by QMetaObject have member-function overhead

38 Qt 5 Slot Connections - Λάμδα Problem: requires C++11 But the underlying Qt mechanism doesn't Can use old-style function objects instead!

39 Λάμδα vs. Function Object vs. PMF Use member functions: for public slots for private slots in C++98 (but consider FOs) Use lambdas: for private slots in C++11 Use function objects: when you would use the same lambda expression more than once less duplication (source and executable code) build collections of (templated) FOs for reusability

40 Λάμδα vs. Function Object Ok, if only used once: [w1,w2](bool enable) { w1->setenabled(enable); w2->setenabled(enable); } Better: Exercise: Use variadic templates to avoid QList and its heap allocation!

41 Related QtWS Talks Giuseppe D'Angelo: QList considered harmful (Lightning Talk) Volker Krause, Among ELFs and DWARFs Thomas McGuire: Effective QML Milian Wolff: Optimizing Qt Applications Marc Mutz: Qt Value Class Design

QStringView. everywhere. Marc Mutz, Senior Software Engineer at KDAB

QStringView. everywhere. Marc Mutz, Senior Software Engineer at KDAB QStringView QStringView everywhere Marc Mutz, Senior Software Engineer at KDAB Intro About me p.2 Intro (cont'd) Author of QStringView p.3 Overview QStringView Using QStringView API Patterns For QStringView