stdlist

What I'm trying to achieve is std::list that contains std::functions . I'm trying to implement a callback system where functions can be added to the list and then the list can be looped through and each function called. What I have in class A is: std::list<std::function<void( bool )>> m_callbacks_forward; bool registerForward( std::function<void(bool)> f ) { m_callbacks_forward.push_back ( f ); return true; }; void GameControllerHub::invokeForward( bool state ) { for( std::list<std::function<void(bool)>>::iterator f = m_callbacks_forward.begin(); f != m_callbacks_forward.end(); ++f ){ f(); } }

I have some C code, where in there are two linked lists(say A and B) and A is inserted at a particular position into B and A still has elements. How do I simulate the same behavior effectively using the C++ STL? If I try splice, it makes the second one empty. Thanks, Gokul. You need to copy the elements. Consider something like this: std::copy(a.begin(), a.end(), std::inserter(b, b_iterator)); If you want the same nodes shared by two lists, this is simply not supported by std::list (STL containers always have exclusive ownership). You can avoid duplicating the elements by storing pointers in

I have a multithreaded application, with an loop waiting for user input as main thread. On the correct input, it is supposed to stop the loop and wait for all other threads, to end propperly. For this purpose I created an std::list in which I put the std::future objects created for thread creation std::list<std::future<int>> threads; threads.emplace_front(std::async(std::launch::async, ...)); I was under the impression, that letting the list run out of scope, should block, until all threads return their main function, because the list s destructor will destrurct all std::future elements and

Check this code: #include "stdafx.h" #include <list> int _tmain(int argc, _TCHAR* argv[]) { std::list<int> mylist; mylist.push_back(1); std::list<int>::iterator i = mylist.end(); if( i == mylist.end() ) printf( "end is end\n" ); mylist.clear(); if( i == mylist.end() ) printf( "never get here because Microsoft seems to " "think the iterator is no longer safe.\n" ); return 0; } Now, according to cplusplus.com this shouldn't be a problem, and in release mode, I think this is fine and doesn't cause any issues really, but debugging becomes impossible as this just bails without letting me continue.

I have a Foo object, and a std::list holding instances of it. My problem is that when I add a new instance to the list, it first calls the ctor but then also the dtor. And then the dtor on another instance (according to the this pointer). A single instance is added to the list but since its dtor (along with its parents) is called, the object cant be used as expected. Heres some simplified code to illustrate the problem: #include <iostream> #include <list> class Foo { public: Foo() { int breakpoint = 0; } ~Foo() { int breakpoint = 0; } }; int main() { std::list<Foo> li; li.push_back(Foo()); }

I have a linked list implementation and I'm experimenting with both Mergesort and QuickSort algorithms. What I don't understand is why the sort operation in std::list is so fast. Looking at the std::list under linux and it appears to be linked list as well, not an array based list. The merge sort I tried almost identical to Dave Gamble's version here: Merge Sort a Linked List Also, I thought I'd try a simple quicksort based on this code: http://www.flipcode.com/archives/Quick_Sort_On_Linked_List.shtml Suprisingly, to sort 10 million random numbers using std::list and sort was around 10 times