In fact, it's amazing and strange not that this didn't come out when you added it to the base class or that without them everything works.Apparently, it's the miracles of optimization that threw out the non-working code.We'll look at this method more carefully. It's a:typename IContainer<Key, T>::IOuterIterator begin() { return OuterIterator(this);//TODO: set to begin } There's a class of Outer Iterator in his ancestor. But C+++ polymorphysics is available only for references and indicators.Not for values! Without a trigger operator, this code shall not work.Usually, this problem is solved as follows: an intermediate link for which polymorphysis is available.I mean, for example, class. IContainer::iteratorwhich is common to all classes of "Fretend" and abstract class. IContainer::IIteratorthat hides the details of implementation.The first class holds the index at the second:class iterator { std::unique_ptr<IIterator> impl; public: iterator(IIterator *impl) :impl(impl) { } //... T& operator *() { return impl->current(); } T operator *() const { return impl->current(); } } However, such a way could lead to productivity if the type of container is well known - virtual challenges are not free.Therefore, in the final class, it makes sense to produce the terator so he can use a specific implementation. This can be done by means of a template (i.e. static polymorphysis):template<typename T> class wellknown_iterator { T impl; public: wellknown_iterator(T &&impl) :impl(std::move(impl)) { } wellknown_iterator() { } //... T& operator *() { return impl.current(); } T operator *() const { return impl.current(); } } In that case, classes IContainer and Container They can look like this:class IContainer { //... protected: virtual IIterator* create_iterator() = 0; public: iterator begin() { return create_iterator(); } iterator end() { return nullptr; } } class Container : IContainer { public: class Iterator : IIterator { // ... }; //... protected: virtual IIterator* create_iterator() { return new Iterator(this); }; public: wellknown_iterator<Iterator> begin() { return Iterator(this); } wellknown_iterator<Iterator> end() { return wellknown_iterator<Iterator>(); } }

But I would like not to use dynamic memory, but to transmit to the designer the reference to the base class.The fulfilment of your wishes in this tract is impossible. In the comments @Vlad from Moscow, you're right to redesign. The reason is simple, and you sounded it yourself, the time of life of a class set up on the glass is limited to the area of the announcement.The exit is three:Try an object built on the glass, make it work completely before it's destroyed.Create an object on the hip, maybe turn it into a shared_ptrиюunique_ptr, and use it as an assignment outside the advertising areaRevise the architecture for the creation/interaction of objects, perhaps it makes sense to use the design pathways of the "favour," "steller," etc. ♪ ♪

Modified d functions func - is a local variable function that will cease to exist after leaving the function. A func() { D d = D(); return A(d); } The reference to this variable outside the function will therefore not be valid.Better make a class data member. A in the form of an index instead of a reference. For example,class A { public: A( B *b ) :b(b) { } private: B *b; }; A func() { D *d = new D(); return A(d); } If, however, you wish to transmit the reference, the reference should also be a function parameter. For exampleA func( D &d ) { return A(d); }

Because it's forbidden. http://eel.is/c++draft/dcl.attr.grammar#7 C+14 (on the reference, a more new version of the paper):[dcl.attr.grammar]p6 Two consecutive left square bracket tokens shall appear only when introducing an attribute-specifier. [ Note: If two consecutive left square brackets appear where an attribute-specifier is not allowed, the program is ill-formed even if the brackets match an alternative grammar production. - end note ]There's even an example:y[[] { return 2; }()] = 2; // error even though attributes are not allowed // in this context. Well, you don't have the first line, either, so...const char *s = "string";

There's no reputation for comment.@Vladimir Martianov, it's all right.BYTE == unsigned char == [0...255] The other thing is, what form does he give? ♪The problem is, SHA1_Update transmitted std::wstring, although in the parameters it accepts a standard blue line. Recommendations:(1) Replace std::wstring ♪ std::string♪(2) Replace SHA1_Update(&sha1handler, &str, str.size()) ♪ SHA1_Update(&sha1handler, str.c_str(), str.size())p.s. You're gonna have to figure something out. FFFFF♪ wstring - separating them, a string - No.

Look, unique_ptr not copied (the uniqueness of the indicator would have been breached). That's why you need to irritate. copies Your elements of the mass, and the references to them.for (auto& i : myList) ...

Actually, there's no need to show anything in the way you've recorded, because the object of the production class is already the object of the base class. So you can just write.A * a = b; And if that's the opposite, B * b = a; problems are starting. Because... It usually says bad design.♪ You want to use a descendant where only an ancestors are used. I mean, basically finishing some kind of tricky behavior where it's not known and should not be known.dynamic_cast It's not possible to disrupt the whole program because you did something wrong. Like,void func(Base*b) { ((Derived*)b)->derivedfunc(); } Here, you're calling for a member's function. Derivedbut not in Base♪ But what happens if you're really going to give me an index. Base? Index other descendant Basewho knows nothing about this function?A dynamic_cast lets at least make sure what's going on is what's needed, that's what's in there. Really. Index Derived♪What before the C-style ghost (A*)b - it's probably closest. reinterpret_cast - just treating the bat as having a different type. No checks. Which is already dangerous, but at least this long word will be put into the eye in the text of the programme: reinterpret_cast - as a hazard indicator. And it's not a joke, I repeat the Straustrup-- about long, inconclusive names. ..._cast♪P.S. I don't need to remind you that when you use it, dynamic_cast There's a need for virtual functions, and explain why?

Maybe you need this:template<template<typename> class F, typename... Types> struct ChooseFrom { }; template<template<typename> class F, typename T1, typename... TRest> struct ChooseFrom<F, T1, TRest...> { inline static void *call(void *arg, char run_time_type_of_arg) { if (run_time_type_of_arg == TypeTrait<T1>::value) return F<T1>::call(arg); else return ChooseFrom<F, TRest...>::call(arg, run_time_type_of_arg); } }; template<template<typename> class F> struct ChooseFrom<F> { inline static void *call(void *arg, char run_time_type_of_arg) { return nullptr; } }; On the other hand, if I were you, I'd try not to bring a type-id ejection into a precision, but to extend the type as a parameter of a template in the program. You could have done that without you. ChooseFromand use straight SomeFunc<T>::call♪

A common idea. Let us face the challenge. U Over time Tu Then we need to maximise the amount. solve(0,Tu) + Cu + solve(Tu+Su,inf)♪ It's already clear that it's a naive solution to take over the first task we're gonna face. I'd say we take over the last task that we're gonna face. 0..NThen we'll figure out the results for her. But it won't be a long time, so the tree will go, but remember the memory.Pseudocod (tasks already quashed at start):for (last_task = 0; last_task < N; last_task ++){ Tree.update(T[last_task] + S[last_task], Tree.max(0,T[last_task]) + C[last_task] ); } cout << Tree.max(0, MAX_INT) << endl; Restoring the answer is no longer a problem. To this end, a tree needs to be changed to recognize not only the value but also the number + the position of the maximum element. Let the tree return {value,time, position}♪ Then:vector<int> ans; int MaxTime = MAX_INT; while (true){ auto tmp = Tree.getFullMax(0,MaxTime); if (tmp.value == 0) break; ans.push_back(tmp.position); MaxTime = tmp.time; } cout << ans.size()<<endl; for (int i=ans.size()-1;i>=0;i--) cout << ans[i]<<" "; It's like without a tree:struct Task{ int t,s,c,n; }; Task task[100000]; long long bestSum[100010]; int goSum[100010]; bool cmp(Task a, Task b){ return a.t + a.s < b.t + b.s; } int main() { freopen("olympiad.in","r",stdin); freopen("olympiad.out","w",stdout); int N; cin >> N; for (int i=0;i<N;i++){ cin >> task[i].t >> task[i].s >> task[i].c; task[i].n = i+1; } sort(task,task + N, cmp); bestSum[0] = 0; Task empt; empt.s = 0; empt.c = 0; empt.n = 0; for (int i=0;i<N;i++){ bestSum[i + 1] = bestSum[i]; goSum[i + 1] = -1; empt.t = task[i].t; int prev = upper_bound(task,task+N,empt,cmp) - task; long long nn = bestSum[prev] + task[i].c; if (nn > bestSum[i + 1]){ goSum[i + 1] = prev; bestSum[i + 1] = nn; } } cout << bestSum[N]<<endl; vector<int> ans; while (N) if (goSum[N] == -1) N--; else { ans.push_back(task[N-1].n); N = goSum[N]; } cout << ans.size() << endl; for (int i=ans.size() -1; i>=0; i--) cout << ans[i]<< " "; cout << endl; } Thus, the author &apos; s idea is generally being pursued. ♪ ♪

Russian letters in utf-8 usually take two baytes. When you choose the first two buoys from the line, you'll probably only get one Russian letter, but maybe if the first of them is another symbol or the length of the utf-8-presentation of the symbol more than 2 byte, the utf-8 sequence of the coding is not correctly interrupted. For the first line of sequence (x192)=192, for the rest (x192)=128. On these grounds, the first and second letters can be cut (in the first bay the sequence length in the single calculation system, but hopefully the correctness of the reference data). Thus, finding the length of the symbol will help the function:int wlen(const string &x, int start) { if(x[start]==0) return 0; if((x[start]&192)!=192) return 1; int i=1; while((x[start+i]&192)==128) i++; return i; } Now, the receipt of the first and second row symbols shall be replaced by:first = line.substr(0, wlen(line, 0)); second = line.substr(first.size(), wlen(line, first.size())); Then you can add an analysis that first.size()==0 || second.size()==0The chat interview revealed that the original file in the windows-1251 coding. You can use a team to codify it in Linux Mint. iconv:iconv -f windows-1251 < исходный_файл > новый_файл If re-coding is required in the programme itself, libiconv may be used https://www.opennet.ru/base/dev/iconv_c.txt.html ♪

ABI with gcc and clang in recent versions is incompatible. We need to retrieve libmysql+++ clang' and the problems will disappear.

Let's see this challenge. We have, say, a vector of the whole numbers, and we want to put on the screen numbers only.How do we do that?void out(const vector<int>& v) { for(auto i: v) if (i > 0) cout << i << " "; } And if you get it out, more than five?void out(const vector<int>& v) { for(auto i: v) if (i > 5) cout << i << " "; } Looks like? Yeah. That's how it pulls them together. void out(const vector<int>& v, int value) { for(auto i: v) if (i > value) cout << i << " "; } But what if we only want to it out? Just the ones that put the sinus down?This can be summarized, for example:void out(const vector<int>& v, bool(*)(int) pred) { for(auto i: v) if (pred(i)) cout << i << " "; } Where? pred a function that checks a certain condition, https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%B5%D0%B4%D0%B8%D0%BA%D0%B0%D1%82 ♪ Only the numbers for which the function is to be removed pred return the meaning. true♪ And as we write it, it's our business. For example, bool pred(int i) { return i > 5; } That's all. The rest is a function, or a lambda, a template or not, from a range of arguments, etc., is not the essence. Predictative function - checking some condition, Pregnantfor his/her argument(s).Well, the predictors are very common in the standard library algorithms.

Reply received https://stackoverflow.com/questions/36667374/how-to-enable-c11-for-android-studio ♪ Michael recommended the use of libc+++ or gnustl. I used gnustl.

To this end, the standard needs to add the withdrawal flows for these types. At this point, there is no such opportunity in C+++. At present, if the console supports utf-8, the reference symbols in utf-8 can be converted and removed.

You can make a class with the operator. It looks incredibly different from the function (kstats, this is how the lambda fumes are implemented):#include "stdio.h" int k = 0; class MyFun{ public: auto operator () (){ k++; printf("Function called: %d\n",k); return *this; } }; main(){ MyFun fun; auto x = fun()()()()()(); } Conclusion:Function called: 1 Function called: 2 Function called: 3 Function called: 4 Function called: 5 Function called: 6

The standard defines range-based for loop equivalent to the following code:{ auto && __range = range - init; for(auto __begin = begin - expr, __end = end - expr; __begin != __end; ++__begin) { for-range-declaration = *__begin; statement } } As you can see, iterators are used inside, so inside the cycle, No. Use a code that can make iterators invalid. In answering your question, no, it is not possible to remove elements from the C++ of containers where the operation results in invalid heterators.

Automatic default designer http://melpon.org/wandbox/permlink/5IipVbUfiOn0oghf ♪ With all the characteristics that follow. Like, it doesn't make a type. https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%BE%D1%81%D1%82%D0%B0%D1%8F_%D1%81%D1%82%D1%80%D1%83%D0%BA%D1%82%D1%83%D1%80%D0%B0_%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D1%85 ♪ It also prevents the use of aggregate initialization:#include <iostream> #include <type_traits> struct X { //X() {} X() = default; int a; int b; }; int main( ) { X x { 1, 2 }; // ошибка, если X - не тривиальный класс. std::cout << std::boolalpha << std::is_trivial<X>::value << "\n"; } When designer is defined as = default Class triviality http://melpon.org/wandbox/permlink/hlN9ZnDPexodksQj if she was before. In this case, it amounts to http://melpon.org/wandbox/permlink/2OohvW8YkOBS9sda an explicit reference to the designer in the class definition.If default designer is defined as = default Out of class definition, it'll still be considered that the designer is provided by the user, and it's also http://melpon.org/wandbox/permlink/bsdWwkWehKN73U7V ♪Footnote to the Standard in this regard (8.4.2/5):A function is user-provided if it is user-declared and not explicitly defaulted or deleted on its first declaration.Differences will also be observed in an attempt to establish a default designer. For example:const X x; result http://melpon.org/wandbox/permlink/VRWRDwfR4tJjlfdU Compilation in classification X Like:struct X { X() = default; int i; }; And compiled. http://melpon.org/wandbox/permlink/68ZLMgiXJvMG066l In the case of a default designer provided by the user:struct X { X() {} int i; }; Another point showing the difference arises when using an empty list of initialization in the determination of the object. For example: X x = { }; compelling all members of the class at = default or missing, obviously. If the designer is defined with the empty body, then this recording will leave the members of the class uninitiated (musor).

If the variable type matches the type of reset, Don't write. T t; return std::move(t);♪We should write. T f() { T t; return t; }as in return variable t is considered rvalue.Standard C++11 It says: http://eel.is/c++draft/class.copy#32 When the criteria for coping/replacement pass ( https://ru.stackoverflow.com/a/425681/177684 , in the case of RVO, met (except the limits on the parameters of the function) and the expression of the copyable object is lvalue, the design choice is as if it were rvalue.One copy pass is NRVO:♪ returnif the function returns the class, and return expression is a name.volatile Automatic storage facility (except the function parameter or catchand his type is the same as the type of return.(* Note: struct and union ♪ https://ru.stackoverflow.com/q/420635/177684 )C++14, wording a little different, case return is considered separately from copying (RVO):When copy/replacement criteria are met [...] and return is lvalue or http://eel.is/c++draft/expr.prim.general#id-expression (i.e., in parentheses) which recognizes an automatic storage facility declared in the body or parameters of the function or expression.Thus, starting with C++11, the standard guarantees that if the optimist is off and the NRVO is not in place, the displacement designer will be caused in the following cases rather than copying:struct T { T(); T(T&&); T(const T&); }; T f() { T t; return t; // Имя локальной переменной, вызов T::T(T&&) } T f() { T t; return (t); // Имя локальной переменной в скобках, вызов T::T(T&&) } T g(T t) { return t; // Имя параметра, вызов T::T(T&&) } Because everything does. std::move(x) - this translates the expression into a reference to rvalue, there's no point in writing. T f() { T t; return move(t); }♪ (This also removes the possibility of NRVO).If the expression return is not a name, the automatic conversion to rvalue will not work.T f1() { struct X { T t; } x; return x.t; // Часть объекта, будет вызов T::T(const T&) // Надо написать std::move(x.t) } T g1(T* pt) { return *pt; // Не имя локальной переменной или параметра, // Надо написать std::move(*pt) } A more complex example:T h1() { T a; while (...) { T b; if (...) { return b; // вызов T::T(T&&) } } return a; // вызов T::T(T&&) } T h2(T a, T b, bool c) { return c ? a : b; // Не имя локальной переменной или параметра, // надо написать std::move(с ? a : b) } If the variable type differs from the type of returned valuethe rules don't work, and you have to write. std::move(t):struct Base { virtual ~Base() {} }; struct Derived : Base {}; std::unique_ptr<Base> f() { std::unique_ptr<Derived> r; return std::move(r); // Нужен явный move, потому что типы разные. }

Prospective improvements:The balance may be replaced by comparison with 10 and subtraction 10 (i.e. less than 20). The idea is, the separation operation is more heavy.You can count the lookup table. (a, b) -> cShe's a little bit of an idea. But I don't think a double lookup would be much faster than a couple of gears/outputs.Algorithmic improvement: since the next member of sequence depends only on the two previous ones, the sequence will be fixed. With only a couple of digits not exceeding 100, the cycle length is not more than 100. Find a predetermined cycle length (separate programme), now number n You can take the cycle length module.Combination 2 and 3 can be counted in advance for answers n 0 to 99, and according to 3 this is enough. Total O(1) decision.

The problem is next. C++ scales are functional, much closer to macroes than to functions/classes. It's a clean compilation time. It is not possible to &quot; mop &quot; the template in such a way that it can then simply be tied to the programme (unlike functions and classes). That's why you're gonna have to keep a text in an objective file anyway, and there's no winning.Why isn't it possible to collate into an objective code in advance? Look at this simple code:template <typename T1, typename T2> void f(T1 t1) { T2 t2 = t1; } That's it. http://en.cppreference.com/w/cpp/language/copy_initialization ♪ Depending on types T1 and T2as well as the visibility of other types at the point of use, it may be combined to challenge the best available http://en.cppreference.com/w/cpp/language/converting_constructor (and type conversion T2 to the type of argument of the designer, if they do not match, http://en.cppreference.com/w/cpp/language/cast_operator standard conversions, numerical conversions, including loss of precision and change of view between the floating point and whole numbers.Do you think it's possible to encrypt this in an objective code (i.e., basically on the assembler) Not knowing at the time of compilation T1 and T2?There's a whole article from EDG analyzing why the export of the templates won't take off or cost the candle: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2003/n1426.pdf ♪ And another one: http://blogs.msmvps.com/vandooren/2008/09/24/c-keyword-of-the-day-export/ ♪In more detail, the following problems (from article EDG):EDG had 1.5 years for design and 3 years for implementation (compared to Java for only two years). However, EDG is not a company, it has good developers, with years of experience in developing C+++ compilers.The typical structure of the C+++ compiler is not suitable for the implementation of this thing. The design of the compiler had to be redesigned, and it was likely that all other developers would have to do so if exports became a mandatory part of the standard.Many mistakes that were not necessarily detectable without the export of the templates (e.g. ODR-rule violation, which is only UB standard), with exports, are in fact mandatory.The formats of the intermediate files will have to change completely.This thing doesn't do so much good: It is believed that the original library code will no longer be required to export the templates. That's not true. As the templates work at a level close to the syntax, together with the libraries, it will be necessary to supply either the text of the templates or its direct equivalent (e.g. syntax tree), as all the information is needed during the installation of the templates.It is believed that the export of the templates will accelerate the compilation and reduce the number of relationships. That's not true, because (in consequence of the syntax nature of the templates) the exported template is impossible in advance. Compilation♪ The combination of the template (at least the syntax tree level) will still have to be repeated this time at the design stage. So the compiler will have to fulfil. at least Same job as no exports.The only real work plus the exports of the templates is that the macs are not leaving the boundaries of the broadcast unit. (In the case of non-export, the macroes defined in the file with the template are &quot; visible &quot; to all who use the template.) This positive effect, however, can be achieved through a stricter code organization; there are other, lighter and more effective methods of addressing this problem at the language standard level.