Edify Programming for C++ Programmers

3.  Non-Modifying sequence operations:   s earch std::vector vecStack;          int vecNeedle1[] = { 40,50,60,70 };          int vecNeedle2[] = { 20,30,50 }; std::vector ::iterator it_search; // vecStack: 10 20 30 40 50 60 70 80 90 for (int i = 1; i // using default comparison: 1. it_search = std::search ( vecStack.begin() , vecStack.end() , vecNeedle1 , vecNeedle1 + 4 ); if (it_search != vecStack.end()) std::cout << "search: needle1 found at position " << (it_search - vecStack.begin()) << '\n'; else std::cout << "search : needle1 not found\n"; // using predicate comparison: auto val = vecNeedle2 + 3; it_search = std::search ( vecStack.begin() , vecStack.end() , vecNeedle2 , vecNeedle2 + 3 , myfunction ); if (it_search != vecStack.end()) std::cout << "search: needle2 found at position " << (it_search - vecStack.begin()) ...

Non-Modifying sequence operations : 1.  Non-modifying sequence operations:   _of (CPP 11) std::array all_of_elem = { 3,5,7,11,13,17,19,23 }; 1. if ( std::all_of ( all_of_elem.begin(),   all_of_elem.end() ,  [](int i) {return i % 2; } )) std::cout << "All the elements are odd numbers.\n"; std::array any_of_elem = { 0,1,-1,3,-3,5,-5 }; 2. if ( std::any_of ( any_of_elem.begin() ,  any_of_elem.end() ,  [](int i) {return i )) std::cout << "There are negative elements in the range.\n"; std::array foo = { 1,2,4,8,16,32,64,128 }; 3. if ( std::none_of ( foo.begin() ,  foo.end() ,  [](int i) {return i )) std::cout << "There are no negative elements in the range.\n"; 2.  Non-modifying sequence operations:   find       std::string myints[] = { "Hello", "Hi", "Bye", "ByeBye" }; std::vector myvector(myints, myints + 4); std::vector ::iterator it;...

http://nectarpost.com/lambda-functions-in-cpp/

/* C++ 11 Update: Delete keyword */ class dog {    public:    dog(const dog& ) = delete; // Prevent copy constructor from being used.                               // Useful when dog holds unsharable resource. } /* For C++ 03: Solution:  Declare them as private functions, but not define them.  -- Members and friends get link-time error, others get compile-time error. */ class dog {    private:    dog& operator=(const dog& rhs);    }; // Note: the same techniques can used to disallow any function from being used. Question: Can we disallow destructor from being used?  /* Solution */ class dog {   public:      void destroyMe() { delete this; }      void dog(string message) { cout<   private:      ~dog() { cout<< m_name.m_str ...

class collar { public: collar() { std::cout <<  " collar is born.\n"; }  //Since collar in dog class invokes default constructor in collar }; class dog { collar m_collar; string& m_name;    // Reference should be initialized, hence leads to an error. }; int main() { dog dog1; } output: main.cc:13: error: no matching function for call to `dog::dog()' main.cc:8: note: candidates are: dog::dog(const dog&) // Add to dog: // string& m_name;  // Result: not compilable because age is not initialized. /* C++ 11 Update: */ class dog {    public:       dog() = default;       dog(string name) {...}; }

std::thread   C++  Thread support library std::thread. Threads enable programs to execute across several processor cores. Defined in header Class : thread Member types : native_handle_type Data Member  id    //represents the id of a thread (public member class) Member functions (constructor)    //constructs new thread object (public member function) (destructor)    //destructs the thread object, underlying thread must be joined or detached  (public member function) operator=    //moves the thread object  Observers  // Covered in NEXT POST Operations    // Covered in NEXT POST Constructor :   #include   void f1 ( int n ) { for ( int i = 0 ; i < 5 ; ++ i ) { std:: cout << "Thread 1 executing \n " ; ++ n ; std:: this_thread :: sleep_for ( std:: chrono :: milliseconds ( 10 ) ) ; ...

weak_ptr : A weak_ptr is created as a copy of shared_ptr. It provides access to an object that is owned by one or more shared_ptr instances, but does not participate in reference counting. The existence or destruction of weak_ptr has no effect on the shared_ptr or its other copies. It is required in some cases to break circular references between shared_ptr instances. Cyclic Dependency (Problems with shared_ptr): Let’s consider a scenario where we have two classes A and B, both have pointers to other classes. So, it’s always be like A is pointing to B and B is pointing to A. Hence, use_count will never reach zero and they never get deleted. A cycle occurs when two or more resources controlled by shared_ptr objects hold mutually referencing shared_ptr objects. For example, a circular linked list with three elements has a head node N0 ; that node holds a shared_ptr object that owns the next node, N1 ; that node holds a shared_ptr object that owns the next node, N2 ; that n...

shared_ptr : Definition: Wraps a reference-counted smart pointer around a dynamically allocated object. Syntax template class shared_ptr;  The shared_ptr class defines an object that uses reference counting to manage resources. A shared_ptr object effectively holds a pointer to the resource that it owns or holds a null pointer. A resource can be owned by more than one shared_ptr object; when the last shared_ptr object that owns a particular resource is destroyed, the resource is freed. A shared_ptr stops owning a resource when it is reassigned or reset. Reference Counting:  It is a technique of storing the number of references, pointers or handles to a resource such as an object, block of memory, disk space or other resources. An object referenced by the contained raw pointer will not be destroyed until reference count is greater than zero i.e. until all copies of shared_ptr have been deleted. So, we should use shared_ptr when we want to assign one raw pointe...

std::unique_ptr : C++11 introduces std::unique_ptr, defined in the header . It is a container for a raw pointer. A unique_ptr explicitly prevents copying of its contained pointer (as would happen with normal assignment), but the std::move function can be used to transfer ownership of the contained pointer to another unique_ptr. Reason for it won’t allow copy : A unique_ptr cannot be copied because its copy constructor and assignment operators are explicitly deleted. std::unique_ptr p1(new int(5)); std::unique_ptr p2 = p1; //Compile error. std::unique_ptr p3 = std::move(p1); //Transfers ownership. p3 now owns the memory and p1 is set to nullptr. p3.reset(); //Deletes the memory. p1.reset(); //Does nothing. Complate Example:  // C++ program to illustrate the use of unique_ptr #include #include using namespace std; class A { public :      void show()      {   ...