C++ Gurus

Adding to this, I know that the thread isn't causing the jitter now, as it consistently logs 16'666'667 to 16'666'668. This is a rendering issue: I get smooth gameplay when the lag phases haven't kicked in using my 3rd approach, but when they finally occur, it isn't visually pleasing. -The second approach is more consistent overall, but still not smooth: There's noticeable jitter due to the timeout drops but it's far less than the 1st approach. However, the jitter remains throughout the entire experience. There's downsides to both, but I prefer smoother gameplay, which makes me prefer the 3rd approach overall. I just don't understand how to keep the thread light, while running every 16 seconds down to the ms without jarring hiccups. I've tried using msleep, but it's very course, which doesn't help my issue. Again, the 2nd approach would be ideal if the timeout never got called so early. Maybe there is a method to prevent that?

Oh right, I forgot about that one. Depending on the content you can apply the same to rows. In any case, since your issue is fixed, please mark the thread as solved using the "Topic Tools" button so that other forum members may know a solution has been found :-)

@Kent-Dorfman said in I hear crickets chirping: Doesn't anyone have any esoteric C++ incantations to discuss. It's too quiet in here. Change of topic: I recently found some esoteric C++ incantations: a constexpr counter based on template instantiation: https://b.atch.se/posts/constexpr-counter/ . However, it seems that this behavior is about to be deprecated (you cannot rely on the order templates are instantiated). At the same time, something quite similar has occured in one of the reflection examples (https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2996r12.html Chapter 3.17 "Compile-Time Ticket Counter"). This reflection proposal has been accepted, so we might be able to safely do a constexpr counter through reflection starting with C++26.

@SimonSchroeder said in Using QList [] operator in const methods: Even if operator[](int) const returns a copy you have the exact same possible race condition in a multithreading environment. The only advantage is that it is fewer lines of code where this might occur. Multithreading seems an irrelevant point though because the competent programmer understands that accessing a shared resource needs a mutex, so if safe programming processes are observed then there is no race condition. re const vs non-const: totally agree and get it. It's the way things are...however, I do sometimes wish nothing was ever const and everything was mutable. :^)

Hi, I think you went the too complicated road: quint16 calculateCrc16Arc(const QByteArray &data) { quint16 crc = 0x0000; const quint16 poly = 0xA001; for (char byte : data) { crc ^= (static_cast<quint8>(byte)); for (int i = 0; i < 8; i++) { crc = (crc & 0x0001) > 0 ? (crc >> 1) ^ poly : (crc >> 1); } } return crc; }

Solved by myself. I found "-utf-8" in two .conf files..

Solved! I think this error was also related to the compiler option "/Zc:hiddenFriend-".

Found it! This error was caused by the compiler option "/Zc:hiddenFriend-" !

In general you define a simple template class like this: template<typename T> class A { }; This can then be used with A<int> myA; Sometimes you want to have a different implementation for a specific type which we call a template specialization: template<> class A<int> { }; Just as with function overloading where the compiler picks the function with the best fit for the parameter types, the compiler will pick the most specific specialization. Sometimes you don't want a specific type but some specific sort of type, e.g. a pointer: template<typename T> class A<T*> { }; Now, if you write A<int*> pInt; or A<double*> pDouble; it will match the specialization for pointers. In the same way class Logger3<R(Args...)> will match any function as template argument. One of the "modern C++" features is Args... which means any number of types (0 or more). (The ... introduces a list of types.) So, R(Args...) can match void() or void(int) or int(double,int) etc. Because we are just interested in the function signature this looks like a function declaration, but without any function name between the return type and the argument list.

When you want to include some headers of a library you also must pass the include path to the compiler. If you use cmake, use target_include_directories() and add the desired include paths there. Later when you use this library (aka you link them with target_link_libraries()), cmake will automatically add the paths specified.

clazy is also using libclang

Hi and welcome to devnet, What are you using currently ? QtQuick ? The graphics view framework ?

See https://doc.qt.io/qt-6/qtcharts-changes-qt6.html

Works. Thank Christian again.

@Redman said in reinterpret_cast for received tcp packets: 01:00:00:00:01:00:01:00:00:00:01:00:00:00:00:00:00:00:01:00:00:00 This is what you'd expect for a packed struct (as you have figures out). It worked before because both sides were using C++ and so both sides were not using packed structs (so much about the "well defined protocol"). In order to not have that problem @J-Hilk is right to write a constructor expecting a QByteArray. For sending you should also pack the members into a QByteArray yourself. This also makes you immune to the order of the members (which is only guaranteed by a very, very recent C++ standard). It is also common practice to order members from biggest to smallest, so you can adhere to alignment rules and still get the most compact representation. This would also solve your problem (on the C++ side; I don't know Python) that you don't have to explicitly pack the struct.

@GrecKo said in Iterator as a member: Tree/Graph-like structure: pick the container with the friendliest API depending on how you plan to access it. Still what @Christian-Ehrlicher and @JonB suggested doesn't sound too bad :) Will definitely try it. Similar question: Why is QButtonGroup using a QHash-map for its member buttons? :)) I doubt that there ever will be thousands of button widgets in one group :)

@SimonSchroeder Your description above is in substance, correct. I had to check it to make sure myself. ;^) By assigning the string literal to an array (const or not) it is considered "auto class". When you create a pointer to the string literal the pointer will "typically" point to a RO-data segment containing the literal.