Il va me falloir un peu de temps pour acquérir les réflexes C++11.
Premiers essais de CMake aujourd'hui :-) Depuis le temps que je souhaitais m'y frotter.
J'aimerai bien que mon petit projet Qompoter (https://github.com/Fylhan/qompoter) sache faire du qmake et du CMake
Jusqu'à aujourd'hui, j'avais un petit script qui me générait tout ce qui va bien pour un enum C++ (avec des binding Qt). Mais Q_ENUM fait ça tout seul !
Cette explication des sémaphores / mutex et autre semblent très intéressantes.
Voilà qui clarifie bien les choses.
La conversion de rvalue en lvalue est assez tordue :
"This doesn't mean that lvalues can't be produced from rvalues by more explicit means. For example, the unary '' (dereference) operator takes an rvalue argument but produces an lvalue as a result. Consider this valid code:
p = &arr[0];
int arr[] = {1, 2};
int
(p + 1) = 10; // OK: p + 1 is an rvalue, but (p + 1) is an lvalue
Conversely, the unary address-of operator '&' takes an lvalue argument and produces an rvalue:
"
int var = 10;
int bad_addr = &(var + 1); // ERROR: lvalue required as unary '&' operand
int addr = &var; // OK: var is an lvalue
&var = 40; // ERROR: lvalue required as left operand
// of assignment
Ces deux derniers point ne sont pas vrais en Qt si c'est dans la définition d'un signal ou d'un slot. Qmake génère un moc_.cpp à partir du .h, et il a besoin des définitions des paramètres.
Cette bibliothèque Qt pour lancer un serveur ou un client HTTP semble idéale (licence MIT). Plus aboutie que QHttpServer (https://github.com/nikhilm/qhttpserver, licence MIT aussi).
ça fait plusieurs développeurs Node.js que je vois aussi faire du C++ avec beaucoup de talent. C'est bien les gars ;-)
Premier article d'une série sur les tests en Qt / C++.
Le site du concepteur de C++. Pas mal de ressources.
P.S : oui, j'avais quelques bookmarks à trier dans ma barre personnelle de Firefox :-D
Inqlude: http://inqlude.org/
Qt Apps : http://qt-apps.org/
Site officiel : http://qt-project.org/wiki/Category:Add-ons
Sur Github : https://github.com/search?nwo=0TheFox0%2FOpenChart&p=7&q=qt+plugin&ref=cmdform&search_target=global&type=Repositories
Le concept de lock-free programming est vraiment intéressant : empêcher les possibilités de blocages, ou les erreurs lors de l'utilisation d'une mémoire partagée entre plusieurs threads. L'idée étant de ne pas utiliser de mutex, et soit de séquentialiser l'accès à la mémoire partagée, soit d'utiliser des petites opérations atomiques (qui seront exécutée sans interruptions).
Il n'est pas tellement vraisemblable de créer un gros programme lock-free, l'idée est plutôt de rester pragmatique et de faire interagir plusieurs parties lock-free entres elles.
Le gain en performance par rapport à des mutex est assez flagrant. Et c'est à mettre en place pour coder efficacement sur du multi-processeur. Mais les compétences pour une mise en œuvre correcte sont aussi plus grandes.
"So keep mutexes, unless you have a lot of lock contention or are looking for a challenge."
Une autre ressource sur le sujet :
http://woboq.com/blog/introduction-to-lockfree-programming.html
Et comment gérer des opérations atomiques en Qt :
http://qt-project.org/doc/qt-5/qatomicint.html
Une définition assez claire de "thread-safe" et "reentrant".
Ok, je crois que je vais me coltiner ça.