link_directories(${PROJECT_NAME} ${SDL2_LIBRARIES}) You're trying instead. catalogues Libraries for lens flags The lens, which makes the lens very embarrassing. You don't have to tell her when it's at the config-module. find_package()the one that goes with the sdl, SDL2_LIBRARIES already includes the way to librarians. -L...So this line can just be down.If you want to clearly point out the way to the library, it's variable. SDL2_LIBDIR:link_directories(${SDL2_LIBDIR}) Also, not a mistake, but in link_directories and include_directories You don't have to send a catalogue. ${PROJECT_NAME} (if there is no such catalogue of includs in fact).

The simplest thing I can offer is to stand in a separate base class.class Base { public: enum class Bat { One = 1, Two = 2 }; }; template <int I> class Foo: public Base { }; template <> class Foo<1>: public Base { void SomeFunction( Bat bat ); }; template <> class Foo<2> : public Base { void SomeFunction( Bat bat ); };

noexcept(false) equivalent to absence noexcept (beside the destructors, maybe something else).What for Throwing(); There's no barning (when there's a direct waiver), it looks like a slight underdevelopment of the compiler, provided the compiler sees the body of the function. Absence of barning ThrowDecl(); It looks logical (as for all the functions the compiler sees no body).One reason to use noexcept - Tell the compiler something he doesn't know.For example, as a programmer, you might know that's not--noexcept The function could not the exception to specific arguments, or for some reason.Or maybe a function never leaves an exception, but noexcept It's forgotten, and you can't add it because it's a library function.Or the naobrot, the exception is possible, but you're sure you won't be able to continue normal work after him, so you'd prefer to get straight. std::terminate♪

This's the problem. std::isupper and std::islower several overloads, some declared <cctype>Others <locale>♪ Apparently default in vc++ and standard gcc library, these headline files are differently included in other headline files. If vc++ is clearly inclined <locale>I don't know what to do.In such cases, there should be a clear indication that the indicator should be preceded by a necessary overload:#include <algorithm> #include <cctype> #include <string> void solve(::std::string & str) { using t_Predicate = int ( * )(int); constexpr auto const p_up{static_cast<t_Predicate>(::std::isupper)}; constexpr auto const p_low{static_cast<t_Predicate>(::std::islower)}; auto const up_num{::std::count_if(str.begin(), str.end(), p_up)}; auto const low_num{::std::count_if(str.begin(), str.end(), p_low)}; if (low_num < up_num) { ::std::for_each(str.begin(), str.end(), p_up); } else { ::std::for_each(str.begin(), str.end(), p_low); } return; } https://godbolt.org/#g:!((g:!((g:!((h:codeEditor,i:(filename:%271%27,fontScale:14,fontUsePx:%270%27,j:1,lang:c%2B%2B,selection:(endColumn:52,endLineNumber:9,positionColumn:52,positionLineNumber:9,selectionStartColumn:52,selectionStartLineNumber:9,startColumn:52,startLineNumber:9),source:%27%23include+%3Calgorithm%3E%0A%23include+%3Ccctype%3E%0A%23include+%3Cstring%3E%0A%0Avoid+solve(::std::string+%26+str)%0A%7B%0A%09using+t_Predicate+%3D+int+(+*+)+(int)%3B%0A%09constexpr+auto+const+p_up%7Bstatic_cast%3Ct_Predicate%3E(::std::isupper)%7D%3B%0A%09constexpr+auto+const+p_low%7Bstatic_cast%3Ct_Predicate%3E(::std::islower)%7D%3B%0A%09auto+const+up_num%7B::std::count_if(str.begin(),+str.end(),+p_up)%7D%3B%0A%09auto+const+low_num%7B::std::count_if(str.begin(),+str.end(),+p_low)%7D%3B%0A%09if+(low_num+%3C+up_num)%0A%09%7B%0A%09%09::std::for_each(str.begin(),+str.end(),+p_up)%3B%0A%09%7D%0A%09else%0A%09%7B%0A%09%09::std::for_each(str.begin(),+str.end(),+p_low)%3B%0A%09%7D%0A%09return%3B%0A%7D%0A%27),l:%275%27,n:%270%27,o:%27C%2B%2B+source+%231%27,t:%270%27)),k:54.412532637075714,l:%274%27,n:%270%27,o:%27%27,s:0,t:%270%27),(g:!((g:!((h:compiler,i:(compiler:g112,filters:(b:%270%27,binary:%271%27,commentOnly:%270%27,demangle:%270%27,directives:%270%27,execute:%271%27,intel:%270%27,libraryCode:%270%27,trim:%271%27),flagsViewOpen:%271%27,fontScale:14,fontUsePx:%270%27,j:1,lang:c%2B%2B,libs:!(),options:%27-std%3Dc%2B%2B17+-Wall+-Wextra+-Wconversion+-Wpedantic+-Werror%27,selection:(endColumn:1,endLineNumber:1,positionColumn:1,positionLineNumber:1,selectionStartColumn:1,selectionStartLineNumber:1,startColumn:1,startLineNumber:1),source:1,tree:%271%27),l:%275%27,n:%270%27,o:%27x86-64+gcc+11.2+(C%2B%2B,+Editor+%231,+Compiler+%231)%27,t:%270%27)),k:50,l:%274%27,m:25.59456398640997,n:%270%27,o:%27%27,s:0,t:%270%27),(g:!((h:output,i:(compiler:1,editor:1,fontScale:14,fontUsePx:%270%27,tree:%271%27,wrap:%270%27),l:%275%27,n:%270%27,o:%27Output+of+x86-64+gcc+11.2+(Compiler+%231)%27,t:%270%27)),header:(),l:%274%27,m:74.40543601359003,n:%270%27,o:%27%27,s:0,t:%270%27)),k:45.587467362924286,l:%273%27,n:%270%27,o:%27%27,t:%270%27)),l:%272%27,n:%270%27,o:%27%27,t:%270%27)),version:4 Z.A. The cctype predictors don't even use at all because they can use the current elbow. Do one normal cycle first, counting the number of letters in the top / bottom register, and then the second normal cycle for the transformation of the register.

At first glance, it seems that const has the character of "depend in code" but it doesn't work everywhere.You just need to add a little const.void print2DimensionalArr (const Point * const * Arr, int n, int m) a Some https://mariusbancila.ro/blog/2018/11/23/join-the-east-const-revolution/ ♪ may say it's better to write that ♪void print2DimensionalArr ( Point const * const* Arr, int n, int m)

In terms_Ctest << Ctest(1); Ctest(1) this is rvalue expression. And then it's trying to call the overloaded operator of the who's referenced. Normal (lvalue) reference cannot be accepted rvalue. What to do is just a way to make a reference to the constant.void Ctest::operator << (const Ctest& _Ctest) { Dtest = _Ctest.Dtest; }; or make this overload:void Ctest::operator << (Ctest&& _Ctest) { Dtest = _Ctest.Dtest; }; I would. const& And that would be enough. But if the object is heavy and can be described as a good function of displacement, the overload and rvalue are the most important.

The results came for the exam. The challenge was almost correct, the error was only in the indices, and the beginning and end of the maximum fever was right. Complex O(n)

Because all 3 standards changed the definition of aggregate and, according to that definition, the types of initialization that occur in this case changed. The configuration of the definitions of the 17 standard has an aggregate initialization that prevents a protected design and makes a mistake.

https://ru.stackoverflow.com/help/minimal-reproducible-example :template<auto x_address> struct Foo {}; char bar[8]{}; Foo<bar + 0> a{}; Foo<bar + 4> b{}; https://godbolt.org/#z:OYLghAFBqd5QCxAYwPYBMCmBRdBLAF1QCcAaPECAM1QDsCBlZAQwBtMQBGAFlJvoCqAZ0wAFAB4gA5AAYppAFZdSrZrVDIApACYAQjt2kR7ZATx1KmWugDCqVgFcAtrS7bSV9ABk8tTADlnACNMYhAANlIAB1QhQnNaO0cXN2jY%2BLofP0CnELDI40xTBIYCZmICJOdXTndC4rpS8oIsgODQiKMyiqqU2q7m1py8iIBKI1QHYmQOKQJMJyjVec0AZhtmByIAanEAfWZ0dGJMISE17E0ZAEEhAmIHU22AMVRUbc0Adn1PgBE1/Q3K7XZAIcrbILlTQAVl0AA4Yf9VoDrq9UGsbJDiB89NsZBdtswvj8kSi0RisTjdNtuASgsSvqTgVJxqxpND5K5ZPJUNIbAYDNshJNppgcatOPICNI5KNxgBrEDaaEqaTcTkynnSeRCEAyUjS7njOCwGCIFCoRZ4dhkCgQNBWm0gYCcV18a3zYi6iBBTWkIK%2BcoAT2kktIDqcVgIAHlaKwQ9zSFgnGpgOw/fgTsUAG6nP2YcRFLazMO%2BeZsxOsPBBYjBuxYP33PBOUMsvh0RgsdM8duCEQSP1KTgqVMoAV6FTV3WQcaoKJmOi6qQAWmXd3Qa1%2BWj0Bk4nx1mBMC9cEE8vRqHmsQ3aYWHMTix/PynvGVo19yHWH9WPTR69mqyjfiU3QtL4bQfreAx/skF53IMYHDJ%2B4zClMMxcKy7IaomvJSOIcLhMu4TcNswDIMg2yugAdJw2wQLghAkOKw7bHYjqhExowseOuhSpqcqkIq0L6hW6qkC2QmkFycikDhOp6gafGkCa5qTAQURbOQlAOlE1qfh4%2BBEJB/CdmwHA9sZwhiJIiYAO61lErYYVIHKSX6OHRls6kENsqBULs%2BGEcRpHkVRNEQKxOk2hxvFGuMCCYIcHQQE5onifqUlalIcn6oasoKkqKoVqsWHSbJClGkpZrKRASDabptpaZakUdMgqjqLUMj6lQHqhN6vqJgGtDBq24aWpG9CxvGGYLKm6aJpmRRmLmS7SQWRbzCNZaHn6VY1nWGCzNJTYtlIkrjMZTCmVwvAWf21nSUo7htRo3GTkE07JTJ84JEuq7rpu276Hoe4HkeCSWNYT7Dp474jHe6SPv%2BfRpA%2BCSw3pQGNCBUNGIei3AfB2Q3oB2NI7BIHo7eyEimhnBOS5GUydIeEEUR2ytamFHaJRMg87R9GGUxpAsU19XitonH8juegxXlAkgKsqyUYrKuq2rqpSKlIASYzZW6jlinVUgqleZp9qi067iYAZJDKBdXZmTdHaWQOtn2Y5GsM250geWpWw%2BX5LOBezz1czzfPhRb7E6KsEuyyycUJVgYSfSJ8hpa52HakY8m5Qn8vaAAnJR0LhIXsefJ8EoyIX2jcNwqwa8VmeldnefGlVVW1VHDXm2xYTZsgURRHs2acIXexF3sABqDCcOEeycDIeziER7qsJ6fV%2BoNw2nfIEZRpNCbScms2HfIC05nmiZrcgxabfQ22VtWtbEEG9bnwaxDNh79tXeZzs7qDgViOdQY5paGF2h9Wc31FzSAAPTrnAUDXQe5tjwKiKEJweAzh4FzMudB%2BBmDAFoLEMwyBdQsBOAQUG%2BMLCnkhmTZQMMELE3hqjOgOMXzHkpoBPGDRaC/kqEwr8/CfwU1YRBEmzQcZwQqLwumExUJmXpiVTKq9iJOCEIPbYY9i5F22LPee1EZD8xttiGOzEIpixjqsSW3F478UVMqDWWsdbeyyjnA2FUjYgBNhpO0dUnSN2tgxIyHZLrdidn2Kyfo7LMAcnvVRLdMq%2By8gHXYbMtE6L0ZRAxRjwgmNotYqKtjRiOMTolFOKV07a3Sh47K5U5bON5g3GQ4RPjaG0OEOEhcZCfFLrwIqaimaePbk5bQIyyrjNILmL04NuBAA%3D Flag assembly /std:c++17 /permissive- /diagnostics:caret received<source>(6,12): error C2975: 'x_address': invalid template argument for 'Foo', expected compile-time constant expression Foo<bar + 4> b{}; ^ <source>(1): note: see declaration of 'x_address' template<auto x_address> In accordance with the standard, the non-type cap parameter may not refer to an item which is an element of the mass:[temp.arg.nontype]2 A template-argument for a non-type template-parameter shall be a converted constant expression (8.20) of the type of the template-parameter. For a non-type template-parameter of reference or pointer type, the value of the constant expression shall not refer to (or for a pointer type, shall not be the address of):- (2.1) a subobject (4.5)- (2.2) a temporary object (15.2),- (2.3) a string literal (5.13.5)- (2.4) the result of a typeid expression (8.2.8), or- (2.5) a predefined func variable (11.4.1).[intro.object]2 Objects can contain other objects, called subobjects. A subobject can be a member subobject (12.2), a base class subobject (Clause 13), or an array element.What do we do? Transfer the removal from the basic address as another metric of the template.

Here's three different options.#include <iostream> #include <vector> #include <chrono> #include <ctime> #include <iomanip> int main() { auto now = std::chrono::system_clock::now(); auto tt = std::chrono::system_clock::to_time_t(now); { // просто вывод в консоль std::cout &lt;&lt; std::put_time(std::localtime(&amp;tt), "%F %T") &lt;&lt; '\n'; } { // выводим в строковый поток, потом уже в строку std::stringstream ss; ss &lt;&lt; std::put_time(std::localtime(&amp;tt), "%F %T"); std::string st = ss.str(); std::cout &lt;&lt; st &lt;&lt; '\n'; } { // в массив символов, потом выводим, но для программистов на си это уже строка char buf[100]; strftime(buf, 100, "%F %T", std::localtime(&amp;tt)); std::cout &lt;&lt; buf; } }

Such a function is easily spelled on a knee. Somewhere.#include <iostream> #include <vector> std::vector<double> linspace(double start, double end, int count) { std::vector<double> r; r.reserve(count); double step = (end - start) / (count-1); for (int i = 0; i < count ; i++) { r.push_back(start + i * step); } return r; } int main() { auto v = linspace(0,1,11); for (auto a : v) { std::cout << a << '\n'; } }

Keep a specific type of data in the callback, not a template. There's a special interface for this.struct ICallable { virtual void operator() (void) const =0; }; // std::function<void(void)> - своими руками, без выделения памятию. template<class Lambda> struct Callable : ICallable { Lambda lambda; Callable(Lambda lambda) : lambda(lambda) {} void operator() (void) const { lambda(); } }; class CallbackRegistry { public: // Сделаем универсально, для любого invorkable набора аргументов. template<class... Args> static void setCallback(Args...args) { auto binded=={ std::invoke(args...); }; // сворачиваем набор аргументов в один. static Callable<decltype(binded)> instance( binded ); // создаем экземпляр Callable. assert(callback==nullptr); callback=&instance; } static ICallable* callback; }; ICallable* CallbackRegistry::callback = nullptr; void HAL_TIM_IC_CaptureCallback(TIM_HandleTypeDef *htim) { if(CallbackRegistry::callback!=nullptr) (*CallbackRegistry::callback)(); } struct Test { void foo() {} } test; CallbackRegistry::setCallback( &Test::foo, & test );

http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0479r5.html The point in the Wikipedia is:The attribute-tokens likely and unlikely may be applied to labels or statementsSo you can add an attribute to the mark or instructions. You can't go to the terrand operator. We need to rewrite if.I want to explain. https://en.cppreference.com/w/cpp/language/attributes/likely where, at first glance, it seems that an attribute is used on the thermal operator: for (auto n{0LL}; n < precision; n += 2LL) { [[likely]] y += pow(x, n) / (n & 2LL ? -fact(n) : fact(n)); } In fact, the attribute is listed here for All instructions in the cycle. There's a parole in the cycle and two paths. One way to go is a way out of the cycle, a second way, with a cycle going. And the idea of this example is to tell the compiler that the way to proceed with the coming into the body of the cycle will more often be done than the way to go.

Something like that. But it only works with the numbers that are compilation times because the type should be determined during the compilation.#include <cstddef> #include <cstdint> #include <iostream> #include <type_traits> // Чем меньше число, тем "лучше" тип. template <typename T> inline constexpr std::size_t type_rank = sizeof(T) * 2 + std::is_unsigned_v<T>; template <auto> struct value_tag {}; // Возвращает тип из списка по его "рангу". // R = value_tag&lt;ранг&gt;. template <typename R, typename ...P> struct get_type_by_rank {}; template <typename T, typename ...P> struct get_type_by_rank<value_tag<type_rank<T>>, T, P...> {using type = T;}; template <typename R, typename T, typename ...P> struct get_type_by_rank<R, T, P...> {using type = typename get_type_by_rank<R, P...>::type;}; // Проверяет, что X представимо типом T. template <auto X, typename T> inline constexpr bool is_representable = []{ static_assert(std::is_integral_v<decltype(X)> && std::is_integral_v<T>); return !std::is_signed_v<T> && X < 0 ? false : X == T(X); }(); // Кастует X к минимальному типу из P.... template <auto X, typename ...P> inline constexpr auto cast_to_smallest = []{ constexpr std::size_t min_rank = []{ std::size_t min_rank = -1; ([&]{ if (type_rank<P> < min_rank && is_representable<X, P>) min_rank = type_rank<P>; }(), ...); return min_rank; }(); return typename get_type_by_rank<value_tag<min_rank>, P...>::type(X); }(); int main() { static_assert(std::is_same_v<const unsigned char, decltype(cast_to_smallest< 0, unsigned char, short, int>)>); static_assert(std::is_same_v<const unsigned char, decltype(cast_to_smallest< 255, unsigned char, short, int>)>); static_assert(std::is_same_v<const short , decltype(cast_to_smallest< 256, unsigned char, short, int>)>); static_assert(std::is_same_v<const short , decltype(cast_to_smallest< 32767, unsigned char, short, int>)>); static_assert(std::is_same_v<const int , decltype(cast_to_smallest< 32768, unsigned char, short, int>)>); static_assert(std::is_same_v<const short , decltype(cast_to_smallest< -1, unsigned char, short, int>)>); static_assert(std::is_same_v<const short , decltype(cast_to_smallest<-32768, unsigned char, short, int>)>); static_assert(std::is_same_v<const int , decltype(cast_to_smallest<-32769, unsigned char, short, int>)>); }

It's the type cycle that makes it simple:template <typename ...Ts> void foo() { ([&]{ // Код здесь выполяется для каждого типа из `Ts...`. std::cout << typeid(Ts).name() << '\n'; }(), ...); } int main() { foo<int, float, double>(); } If you need to know more about the type index (as the compilation timeline), then it's a little harder:template <typename Integer, Integer ...I, typename F> constexpr void constexpr_for_each(std::integer_sequence<Integer, I...>, F &&func) { (func(std::integral_constant<Integer, I>{}) , ...); } template <auto N, typename F> constexpr void constexpr_for(F &&func) { if constexpr (N > 0) constexpr_for_each(std::make_integer_sequence<decltype(N), N>{}, std::forward<F>(func)); } And then like,template <typename ...Ts> void foo() { using tuple_t = std::tuple<Ts...>; constexpr_for&lt;std::tuple_size_v&lt;tuple_t&gt;&gt;([&amp;](auto index) { constexpr auto i = index.value; std::cout &lt;&lt; typeid(std::tuple_element_t&lt;i, tuple_t&gt;).name() &lt;&lt; '\n'; }); }

Well, as in the previous reply, I'm not a contender, maybe even the answer isn't exactly correct.template <typename T, typename MT> auto min_type() { return conditional_t < sizeof(T) < sizeof(MT), T, MT >{} ; } template <typename T, typename U, typename V, typename ...Ts> auto min_type() { return min_type<T,decltype(min_type<U,V,Ts...>())>(); }; template <typename ...T> using min_t = decltype(min_type<T...>()); int main() { cout << is_same_v<int8_t,min_t<int16_t, int32_t, int8_t, long long>> << endl; cout << is_same_v<int16_t,min_t<int16_t, int32_t, int8_t, long long>> << endl; } Yeah, I didn't do a fool's defense, but it's easy. ♪ ♪

The best answers are: https://stackoverflow.com/questions/66063164/how-can-i-change-gui-from-stdthread P.S. Yeah, in English, who doesn't know him, use it.yandex.ru for websites.

You write about your own inheritance - so, can you do your inheritance?struct Generic { int some_field; int SomeMethod(int val) { some_field = val; return 2; }; }; template <class T> class Foo: public Generic { public: }; // Но при специализации общая часть пропадает. template <> class Foo <std::string>: public Generic { public: }; Or even : public Generic - Too much?

How rightly observed https://developercommunity.visualstudio.com/content/problem/108672/unable-to-move-stdpackaged-task-into-any-stl-conta.html , this is the MSVC Compiler's tag, which was fixed and planned to correct at the next major release.As has been said, one possible solution to circumvent this restriction is to remove it. std::packaged_task Intelligent indicator (creation) std::make_shared) If the remaining parameters (args) are also available std::packaged_task Objects, they'll have to be wrapped, too.The code below operates under Windows (MSVC) and Linux (CLang/G++). Only a condition under Linux is the addition of the option. -pthread, without her std:packaged_task leaves an exception std:system_error "Unknown error -1"♪The working code is lower (contains both task and args): https://rextester.com/WEYC49656 https://godbolt.org/z/M4h8Eh #include <iostream> #include <functional> #include <future> #include <deque> #include <memory> template<class T> struct Caller; template<class R, class... Args> struct Caller<R(Args...)> { using PackagedTask = std::packaged_task<R(Args...)>; using InternalTask = std::packaged_task<void(void)>; void enque(PackagedTask&amp;&amp; task, Args&amp;&amp;... args) { auto fnc = [](auto&amp;&amp; task, auto&amp;&amp;... args) -&gt; void { if (task-&gt;valid()) (*task)(std::forward&lt;Args&gt;(*args)...); }; auto bnd = std::bind(std::move(fnc), std::make_shared&lt;PackagedTask&gt;(std::forward&lt;PackagedTask&gt;(task)), std::make_shared&lt;Args&gt;(std::forward&lt;Args&gt;(args))...); m_tasks.emplace_back(std::move(bnd)); } void run() { if (!m_tasks.empty()) { auto&amp; task = m_tasks.front(); if (task.valid()) task(); m_tasks.pop_front(); } } std::deque&lt;InternalTask&gt; m_tasks; }; int main() { std::packaged_task<int(int)> task { [](auto a) { std::cout << "tra-ta-ta: " << a << std::endl; return 5; } }; Caller&lt;int(int)&gt; c; c.enque(std::move(task), 5); c.run(); }

It is felt that there are no solutions within the framework. I mean, there are many, but each of them will bring their own problems, the need for compromises, etc.For example, the use of asynchronicity, as is the case in the same Qt, can be followed by some turn for reverse calls (collebacks). But in that case, someone must constantly question and execute the collbecks contained therein. Whether this is a global pool of flows or the current flow will be organized by a cycle processor of similar events, all of which will in any case lead to a break in perceptions and the addition of new ones that were not necessarily necessary.Or, for example, it is possible to re-check an atomar flag that will say whether the current flow is already protected by the relevant music or not. In this case, the Myutex will not be blocked in a recurring manner, it will always be known that any challenge unlock(s) will lead to its complete release, rather than the possible partial, which is obviously a classic music. But this decision also brings its five copies into a set of underwater stones. It will be necessary to fertilize these flags or to draw references to them in the village of objects and to have at each level in the places where each of the music is used.Or, for example, it is possible to organise the transfer of the collback as an argument of the function to avoid ruptures. Something like, we recall the Funker's argument, the context of implementation reverts to the highest level of the tree, releases the previously blocked mythex, and then it's starting to collback. But there are a number of problems in this solution, starting with the fact that the ropes on the way down the hierarchy of the calls can be much and end up with the need for the programmer to monitor when and at which level a collback should be performed. All of this will definitely turn into a headache.What in turn is the bad recurring mythex? At least:In each specific context, the challenge unlock(s) does not guarantee the complete release of the music;The myth must be blocked for as short a time as possible (why do we have a multi-proofness?) that in the recurring block it is becoming less attainable;Overhead due to checking on the current track every time each blocking.