C++ Gurus

FWIW, since you are using the STL streams classes, note that you have buffer size control in the STL classes. One could weakly argue that you should use the Qt file IO methods instead of STL streams, since mixing frameworks is often the cause of problems in programming.

@Pl45m4
I am now good on the algorithm. The one I am using (via @J-Hilk/ChatGPT) gives me a satisfactory answer I can work with and place my objects.

@SimonSchroeder
Sorry, but I don't think any part of my questions relate to random numbers or generators or distribution/uniformity performance. They are questions about C++ (especially the as-yet-unanswered question #3). With regard to the static-ness/number of times to call the initial "seeding" when comes with std::random_device rd; std::mt19937 gen(rd()); I only wish to reseed once and then accept the random number which comes from that, as is standard practice with random number generators (e.g. for old-style rand() we used to call srand() just once).

QString myString = "First line\nSecond line"

@Qtpp said in How to find symbols in extern code files or projects and get their "type" (code analysis library)?:

is it somehow possible to reach out to one of the QtCreator maintainers/devs

https://lists.qt-project.org/listinfo/qt-creator

@SimonSchroeder said:

But I'm not sure if this distinction is possible

It's not. The delete operator can't be cv qualified.

Here's a fun quirk:

struct Foo { void itIsFine() const { delete this; } ~Foo() { bar = 42; } int bar = 0; }; const Foo* foo = new Foo(); foo->itIsFine();

so not only can you delete an object through a pointer to const, but a const function can mutate the object without mutable or const_cast by deleting the object it is being called on;)

@jeremy_k

that is weird. some examples place the directive after the declaration and others before like it shouldn't matter...but you are right. It did make a different. Placing it before the declation cause the warning to be igrnored.

looks like gcc documention is wrong...go figure. LOL

wrong in TWO PLACES...First, they say "unused" is a valid attribute, and second, internal examples sometimes place the attribute after the decl.

Hmmm.

@mzimmers said in can't compare lists of my struct:

I removed the QObject derivation, and now it seems to work.

If you don't plan to ever use meta-object related stuff, then you really don't need a QObject derived class or the Q_OBJECT macro (for metacalls / qt signals).

Which Qt Version and C++ standard are you using?

I have a same question,but I can't change Qt Version or c++ standard. do you have other suggestions?
Thank you in advance for your help

@Bharath-kumar
As @Christian-Ehrlicher has said. I don't understand: in your code you know how to produce a certain number of digits via QString formattedString = QString::number(doubleValue, 'e' , 4);, so why do you have QString dataString = data.toString(); earlier and expect that to produce a limited number of digits?

@JonB said in matherror issue:

If the int _matherr (struct _exception *pexcept) appears in merr.c you need to trace from there to find out where it (_exception) is defined. Maybe it's a MinGW-only definition/file, I don't know.

If I compile in Clang

int err_ind = 0; int _matherr (struct _exception *pexcept) { err_ind = 1; }

Compilation OK, but math exception doesn't work

If you want an integrated application (not the variant with QProcess that @SGaist suggested), the first step would be to separate your command line application: parse the command line parameters into variables and the actual functionality should then be refactored to a separate function, that takes these variables as function arguments. This ensures, that the same function can be called from your GUI application. Inside the GUI application you would then have input widgets for each variable and a button labeled "Run" (or similar). When "Run" is clicked, you collect all the different inputs and call your refactored function. If this takes longer to run, you should put it into a separate thread (and then the other solution "use a QProcess" is not too different to implement, though for the perfect solution threads should be used, but QProcess will be easier). Maybe for threading a simple QtConcurrent::run() will suffice.

You will have some trouble if there is important console output (writing to stdout/stderr) of your existing application. How do you want to interact/signal errors? For a good solution this would require deeper changes into your existing application. With the QProcess approach the only thing you can do is to show the output to the user. Otherwise, you could use callback function for output. In the case of your command line application this can still write to the console by default, and for your GUI application you register a callback that shows a QMessageBox. Maybe the callback can even return a value (e.g. from the message box) to continue or abort.

@JonB

I think it's some kind of hint for the reader to understand the source code better without browsing the whole class.
Like:

in some class.h where someFunction(int a, int b, float c) is declared

void someFunction(int a, int b, float c);

and (if I'm correct) everywhere the function is used, on every call, the code browser adds the names from the header, so you know right away what this

// some code // ... someFunction(42, 42, 13.37); // ...

means.

With the hint it looks like:
( imagine meaningful names there :D )

someFunction( [ a ]: 42, [ b ]: 42, [ c ]: 13.37);

Therefore I don't think it's C++ :)
Btw: I also like woboq to check Qt source code :)

@mzimmers inline might be more convenient. No need to define it in cpp file.

inline static bool m_use24hourTime{ false };

I think you will have to use something like https://www.openldap.org/software/man.cgi?query=ldap

@J-Hilk said in Repost Parent / children / methods ? which way up ?:

(Robert C. Martin, Clean Code: A Handbook of Agile Software Craftsmanship)

Oh boy... Had to read this for my studies :D
Pretty helpful and well structured "guide" on how (not) to write code.

@J-Hilk arrrrrrrrrrrrr

QAction *action = qobject_cast<QAction *>(pItemObject);

Has been explained to you before.