we're getting into very compiler/platform specific features with trying to stuff the data and using pragmas to do it. I've learned to avoid it altogether and to defined memory regions as simple uint8_t vectors, then to write accessor methods that push and pull the data by brute force and bit shifting/stuffing. I must do this a lot with ad-hoc networking protocols. One thing you never want to do is

int v =*(int*)&(vec[17]);

at the minimum it creates an innefficient memory access, and at the maximum generates an alignment fault on some processors. The better way is:

int v; memcpy(&v, &vec[17], sizeof(int));

manually setting significant bit order if necessary

@Chris-Kawa said in static in lambda:

these lambdas, although look the same are of different types internally.

Yes, that I do realise! Just as in C/C++ struct { int foo; } and another struct { int foo; } are not the same type. (But I think they are in Pascal-like languages....)

So you're right - this example will share the static because the type of the lambda is the same in this case

Which I think would make @J-Hilk's original not behave as anticipated if more than connect() is made! :)

this problem would make an cool interview exercise for someone expected to write waveform analysis software. LOL

@Gabriela20 It is a header-only library. Include the header file(s) (per instructions from the git project page) and have fun.

do you know that size of the array in advance?
can you create and access it using subscripts? or what is the reason for creation by pointer...since when talking about arrays the generally accepted access method is by subscript, and only by pointer as a possible optimization later.

std::string my2dStringArray[20][10];
20 rows of 10 columns worth of strings now exist.

or int myInts[] = new int[row*col];
auto v = myInts[(col * y) + x];

@JonB Thanks for your insight. I did as you suggested and found one of my local variable's address a nullptr(though not sure where it came from). I changed a few lines of code and apparently, my code works fine now. @Christian-Ehrlicher @J-Hilk thanks!

Hi @Kent-Dorfman and @Eukaryote ! :)

Of course, I have read and viewed the documentation.
However, I have problems with the realization. I am a beginner and have not yet come into contact with this topic. For this reason, I thought I could find support here.

@JonB said in C++ terseness challenge!:

Yes, I could write my own function for those 3 lines

I once heard from a colleague that they sold their code to a different company. They had a rule that all functions were allowed to have at most 3 lines of code. So, they started intensive refactoring to meat that goal. In your case you did plan for a separate function in your small example. This would be a 6-line function which I would say is okay. But as I said, this is down to preference.

I thought that there were proposals to extend C++ so that the algorithm functions can take a container directly instead of its iterators. However, I couldn't find anything on that right away. I would immediately switch to this approach if it were slightly less verbose. Does anyone have information if we can now write this?

std::copy_if(buttons, std::back_inserter(checkedButtons), std::mem_fn(&QAbstractButton::isChecked));

I thought this was already introduced with std::span, but couldn't find it on cppreference.com.

The problem would be avoided by thinking about the safety of the operation. storing the difference of the values in a temporary is more readable than the original expression, and has the desirable side effect of making the type of the result explicit. Furthermore, putting the lower bound conditional after the upper bound conditional is goofy.

int diff = (x - y);
if ((diff > -10) && ((diff < 10)) { true; }

I suppose you could implement the conditional expression as a lambda if you're into such things, but IMHO that too would make it less readable.

I'd suggest that a class with many instance vars (traits) often indicates a design error and less than optimal use of subclassing. IOW, trying to do too much in a single scope. This is often the result of incremental development, without a clear architecture proposal before coding....not always, but often.

It's not critical to initialize vars by the initializer list, but do initialize them in proper order. I often defer trait initialization to a private Init() method because it looks cleaner. At least in recent c++ versions you can do nested constructors.

@jsulm Change [=] to [=, &s]

@J-Hilk said in Trying to create a simple subclass:

try deleting your shadow build project, maybe old build artifacts cause problems here

@ffej2ffej
As @J-Hilk says. It should not be like this, but it's a nasty lesson to learn with Qt building in practice: whenever you get an "inexplicable" compile/link message and you are "sure" your code is correct, start by deleting all the contents of the build output directory and rebuild from scratch, before puzzling further. This applies particularly when you have made a change in a header file to do with classes inheriting from QObject/changing whether they have Q_OBJECT macro, and similar....

@Kent-Dorfman
Indeed so! Hence I pasted the definition, showing that in the NDEBUG case it's not just that it does not verify the expression result, it's that it does not even evaluate (call) it. So any expression which has any side-effects should not be directly passed as argument to assert(), your code will not execute the CDSTest at all! And that will mean the child will continue into the pid != 0 (i.e. parent) code below, and continue running as a forked copy in parallel, with consequences. (IIRC, you should follow an execvp() in child with _exit(...), just in case....)

Hence my fear of your rocket maybe crashing onto my head ;-)

@chrabaszcz-patryk Confirming this works, was trying to install ODBC and had the same error as OP. Did the suggested steps by @chrabaszcz-patryk and it worked on Qt 5.11.3 on Rpi 4B.

I always throw on a failed constructor so that the object pointer is left alone and nothing becomes "partially initialized". Being that you are wrapping the object construction in an additional layer, you could throw to your method and record status as a return code. I prefer the following standard for method prototypes where possible.

status = method(outparam&, inparam, inparam=value);

@Christian-Ehrlicher
Yep, thanks @Christian-Ehrlicher, at least I know where I am :)
I'll mark yours as solution tomorrow, just in case anyone else finds this worthy of commenting in....

Use my template, it's working as expected :)

@Christian-Ehrlicher
Yes, but see the complainant in the first post at https://gcc.gnu.org/bugzilla/show_bug.cgi?id=46476. I feel his pain.

I ran

int func() { return 1; return 2; }

through a variety of the compilers at that Compiler Explorer/godbolt. Not one of them warned. Is it that we cannot set/adjust any compilation warnings there? I know you won't agree, but it's just sad that none of them offer to warn on the above :) :(