@Konstantin-Tokarev said in Prebuilt number range generators?:

irange

Thanks for the irange suggestion:

for(auto x: boost::irange(10,20)){ qInfo() << x; }

out:

10 11 12 13 14 15 16 17 18 19

I have this book. I have read chapter 1. I was on the fence as to the value of FP. The first chapter definitely has concrete and relatable examples of how the FP approach can improve my code. It does not espouse the idea of only using FP, but a more pragmatic approach of balancing how you think about code. I like the idea of adding tools to my toolbox rather than upending how I write code altogether. The best way to describe the approach this book is taking so far is: thinking about the process versus thinking about the steps. It is very similar to process control in that respect. So its a refreshing way to model code. I expect good things in the next chapters.

@kshegunov
It doesn't help that the OP's code uses std::all_of while his comment has "I like the idea of std::any_of"....

Which is just as easy using your "old and tested way, which is rather simple and explicit":

for (size_t i = 1, size = sequence.size(); i < size; i++) { if (board[sequence[0]] != board[sequence[i]]) return false; } return true;

At a glance verification of an enums value rather than counting lines. Saves coder time. One goal of good programming is being able to maintain code. So making it easier to troubleshoot a value quickly meets that requirement.

@Kent-Dorfman said in Tieing the lifetime of an object to that of a lambda?:

Personally I think lambdas are way too overused

I think at this point I am more interested in the "neat" factor than the utility. I think it will be a nice tool to attach objects as needed to signals, or to graft simpler signals onto more complex outputs. I could imagine this being used as a generator of objects. Lambda capture also reminds me of RAII as used in objects.

So the technical reason for now "cause its cools, and could be useful...maybe".

@fcarney said in Creating an enum like structure for data types other than integral?:

Are there other, better ways to make enum like structures for data types other than integrals?

Not really, but you can "improve" your struct based solution by making the members static: then you don't have to create an instance of the struct and you can do:

Token::Invalid

Also, since enum values cannot be changed you should make the struct elements const:

struct Token{ static const QString Invalid; static const QString P1; static const QString P2; } const QString Token::Invalid = " "; const QString Token::P1 = "X"; const QString Token::P2 = "O";

@aha_1980 Thank you very much. I start working on that!!

Ok, thank you all, you have answered my question. I guess this is time to read some documentation...

@wraitii Thanks for information! You've probably meant libstdc++ and libc++, because libc is kinda different thing

This feature allows to return values of "hidden" type from library which can be used only with auto or passed as an argument to some other library function.

For example, standard library of C++17 introduces a concept of node handle, type of which is left as implementation detail and may be different between implementations or their versions. You can do a few operations with node handles, but cannot ever reference their "true" type.

@VRonin

Hello m8

Thankyou verry much for all your help.
ALL is working like it should thanks to you.

Until next time
Xmodpt

@kshegunov said in compiler reports that Ui is an incomplete type:

error: allocation of incomplete type 'Ui::WifiSetup'

This means the class declaration is not available. Troubleshoot as follows (skip steps that you've checked already):

Make sure you include the generated header where you allocate. Make sure qmake's rerun Make sure the name of the widget in the designer matches the name of the class.

Ding. It was #3, a result of my hasty editing in Designer. Thanks to all who looked at this.

Folks,

Thanks for the direction. The escape character for QStrings is \. So the solution is

QString exeName = "\"" + dirName + "Program.exe\"";

Kris

@fcarney said in template/macro for reducing redundant functions?:

Okay, I think I get it.

Partly. What a template is from the point of view of the binary is nothing - it does not produce anything. A template is way to tell your compiler to substitute template arguments at some point and produce a real living class (or function) which it then can compile to assembly. Instantiation happens on first use with a given set of template parameters ordinarily. In this case I "abuse" that peculiarity by saying: okay, there is a template function (the declaration) but when you need to substitute the types (i.e. instantiate the template on use) you can't, because you don't know the function body.

The extern template at the end is to make all that at all useful - fine there's no body, so the template can't be instantiated in the user code, but I can give you some instantiations I made explicitly somewhere else (in this case in the source). So it works like this:

The compiler sees there's a declaration. It also sees there are 2, 3, 4 instantiations that are done somewhere else (i.e. the declarations at the bottom). In the source it has the template body, and has been told to instantiate the template - that's fine, it can as it knows how. When you use it somewhere it matches the stuff that's declared (i.e. the template declaration and the instantiations) against what you request. It puts a reference for the linker to resolve. If there's an instantiation provided for the given set of template parameters, everything is fine - the linker's going to clean up the mess and link the function you have with the usage. If not, i.e. you used the template with a parameter that hand't been explicitly instantiated, then the linker complains - there's no such thing.

@Konstantin-Tokarev It worked. Thank you. I had been looking at that warning for months. Final solution didn't require to move pure virtual function's definition to *.cpp. I'll leave it here for future seekers.
DLL *.pro

DEFINES += APPLICATIONMODEL_LIBRARY

DLL and EXE *.h

#ifdef APPLICATIONMODEL_LIBRARY # define APPLICATIONMODEL_EXPORT Q_DECL_EXPORT #else # define APPLICATIONMODEL_EXPORT Q_DECL_IMPORT #endif

DLL *.h

class APPLICATIONMODEL_EXPORT CActionFunctor { public: virtual ~CActionFunctor(); virtual void operator()() = 0; }; template <typename TClass> class TActionFunctor : public CActionFunctor { public: TActionFunctor(TClass *object, void(TClass::*function)()) { Object = object; Function = function; } void operator()() { (*Object.*Function)(); } private: TClass *Object; void (TClass::*Function)(); };

DDL *.cpp

CActionFunctor::~CActionFunctor() { } APPLICATIONMODEL_EXPORT CActionFunctor *SimulationInstanceChanged = nullptr; void CSimulation::Bind(CSimulation **simulation) { *simulation = this; (*SimulationInstanceChanged)(); }

EXE *.cpp

APPLICATIONMODEL_EXPORT CActionFunctor *SimulationInstanceChanged; WMain::WMain() { SimulationInstanceChanged = new TActionFunctor<WMain>(this, &WMain::OnSimulationInstanceChanged); }

Hello @JonB, @J-Hilk, @Konstantin-Tokarev,

Once again thank you very much for your help.

Now I have understood it correctly.

@kshegunov
Well the use case was to match the interface currently being used to provide variables to the tr() (translate functions). We have code that looks like this:

tr("Log Message","Status: %1").arg(2)

Well the problem with this is the string is in a server and the client needs to translate the message. So I wanted to wrap the message in a similar way and use the same arg() interface we currently use.

JMsg(QT_TRANSLATE_NOOP("Log Message","Hello: %1 %2 %3")).arg(1).arg("full").arg("world");

The JMsg overloads an operator:

operator QString(){return toString();}

This allows the call to be very similar to the original tr() call and return a string to the function it is created in. JMsg is intended to be a temporary variable. The string it produces is a JSON string that embeds the message with parameters and the args in a list. This is decoded by the client and translated using a function designed to interpret the JSON code.

So effectively I am modeling it after how the translate parameter system works, for the API anyway. Not the underlying code.

I don't program javascript or java much. Mainly C++ and Python.