What comparator are you using?

For the default this will work:

    if(!myset.empty())
        *myset.rbegin();
    else
        //the set is empty

This will also be constant time instead of linear like the max_element solution.

Sets are always ordered.  Assuming you are using the default comparison (less&lt;int&gt;), just grab the last element in the set.  rbegin() might be useful.

I believe you are looking for [`std::max_element`][1]:

&gt; The `max_element()` function returns an
&gt; iterator to the largest element in the
&gt; range [start,end).


  [1]: http://www.cppreference.com/wiki/stl/algorithm/max_element

Since set sorts the element in ascending order by default, just pick up the last element in the set.

    if(!myset.empty())
        *myset.rend();
    else
        //the set is empty
In an ordered integer set, the last element is the largest one.

Before you `push()` in your `set&lt;int&gt;` save the value in `int max` in global variable

Is there a better way than this to splice an array into another array in javascript

    var string = &#39;theArray.splice(&#39;+start+&#39;, &#39;+number+&#39;,&quot;&#39;+newItemsArray.join(&#39;&quot;,&quot;&#39;)+&#39;&quot;);&#39;;
    eval(string);

A better way to splice an array into an array in javascript

How can I tell, with something like `objdump`, if an object file has been built with `-fPIC`?


How can I tell, with something like objdump, if an object file has been built with -fPIC?

I have a `std::set&lt;int&gt;`, what&#39;s the proper way to find the largest int in this set?

How do I find the largest int in a std::set&lt;int&gt;?

<p>I have a <code>std::set&#x3C;int></code>, what's the proper way to find the largest int in this set?</p>


C++0x is introducing `unordered_set` which is available in `boost` and many other places. What I understand is that `unordered_set` is hash table with `O(1)` lookup complexity. On the other hand, `set` is nothing but a tree with `log(n)` lookup complexity. **Why on earth would anyone use `set` instead of `unordered_set`? i.e is there a need for `set` anymore?**

Why would anyone use set instead of unordered_set?

Dynamic allocations with `new/delete` are said to take place on the **free-store**,&lt;br&gt;while `malloc/free` operations use the **heap**.
&lt;br&gt;&lt;br&gt;
I&#39;d like to know if there is an actual difference, in practice.&lt;br&gt;
Do compilers make a distinction between the two terms? (*Free store* and *Heap*, not `new/malloc`)

C++, Free-Store vs Heap

Suppose that I have an integer variable in a class, and this variable may be concurrently modified by other threads. Writes are protected by a mutex. Do I need to protect reads too? I&#39;ve heard that there are some hardware architectures on which, if one thread modifies a variable, and another thread reads it, then the read result will be garbage; in this case I do need to protect reads. I&#39;ve never seen such architectures though.

This question assumes that a single transaction only consists of updating a single integer variable so I&#39;m not worried about the states of any other variables that might also be involved in a transaction.

Is it safe to read an integer variable that&#39;s being concurrently modified without locking?

Sometimes, it is useful to hide a string from a binary (executable) file.
For example, it makes sense to hide encryption keys from binaries.

When I say “hide”, I mean making strings harder to find in the compiled binary.

For example, this code:

    const char* encryptionKey = &quot;My strong encryption key&quot;;
    // Using the key

after compilation produces an executable file with the following in its data section:

&lt;!-- language: lang-none --&gt;

    4D 79 20 73 74 72 6F 6E-67 20 65 6E 63 72 79 70   |My strong encryp|
    74 69 6F 6E 20 6B 65 79                           |tion key        |

You can see that our secret string can be easily found and/or modified.

I could hide the string…

    char encryptionKey[30];
    int n = 0;
    encryptionKey[n++] = &#39;M&#39;;
    encryptionKey[n++] = &#39;y&#39;;
    encryptionKey[n++] = &#39; &#39;;
    encryptionKey[n++] = &#39;s&#39;;
    encryptionKey[n++] = &#39;t&#39;;
    encryptionKey[n++] = &#39;r&#39;;
    encryptionKey[n++] = &#39;o&#39;;
    encryptionKey[n++] = &#39;n&#39;;
    encryptionKey[n++] = &#39;g&#39;;
    encryptionKey[n++] = &#39; &#39;;
    encryptionKey[n++] = &#39;e&#39;;
    encryptionKey[n++] = &#39;n&#39;;
    encryptionKey[n++] = &#39;c&#39;;
    encryptionKey[n++] = &#39;r&#39;;
    encryptionKey[n++] = &#39;y&#39;;
    encryptionKey[n++] = &#39;p&#39;;
    encryptionKey[n++] = &#39;t&#39;;
    encryptionKey[n++] = &#39;i&#39;;
    encryptionKey[n++] = &#39;o&#39;;
    encryptionKey[n++] = &#39;n&#39;;
    encryptionKey[n++] = &#39; &#39;;
    encryptionKey[n++] = &#39;k&#39;;
    encryptionKey[n++] = &#39;e&#39;;
    encryptionKey[n++] = &#39;y&#39;;

…but it&#39;s not a nice method. Any better ideas?

PS: I know that merely hiding secrets doesn&#39;t work against a determined attacker, but it&#39;s much better than nothing…

Also, I know about assymetric encryption, but it&#39;s not acceptable in this case. I am refactoring an existing appication which uses Blowfish encryption and passes encrypted data to the server (the server decrypts the data with the same key).

I **can&#39;t** change the encryption algorithm because I need to provide backward compatibility. I **can&#39;t** even change the encryption key.

How to hide a string in binary code?

&lt;i&gt;&lt;b&gt;Update:&lt;/b&gt; the shared_ptr in this example is like the one in Boost, but it doesn&#39;t support shared_polymorphic_downcast (or dynamic_pointer_cast or static_pointer_cast for that matter)!&lt;/i&gt;

I&#39;m trying to initialize a shared pointer to a derived class without losing the reference count:

    struct Base { };
    struct Derived : public Base { };
    shared_ptr&lt;Base&gt; base(new Base());
    shared_ptr&lt;Derived&gt; derived;

    // error: invalid conversion from &#39;Base* const&#39; to &#39;Derived*&#39;
    derived = base;  

So far, so good.  I didn&#39;t expect C++ to implicitly convert Base* to Derived*.  However, I do want the functionality expressed by the code (that is, maintaining the reference count while downcasting the base pointer). My first thought was to provide a cast operator in Base so that an implicit conversion to Derived could take place (for pedants: I would check that the down cast is valid, don&#39;t worry):

    struct Base {
      operator Derived* ();
    }
    // ...
    Base::operator Derived* () {
      return down_cast&lt;Derived*&gt;(this);
    }

Well, it didn&#39;t help. It seems the compiler completely ignored my typecast operator. Any ideas how I could make the shared_ptr assignment work? For extra points: what kind of type `Base* const` is?  `const Base*` I understand, but `Base* const`?  What does `const` refer to in this case?


Downcasting shared_ptr&lt;Base&gt; to shared_ptr&lt;Derived&gt;?

I&#39;m using a vector of pointers to objects. These objects are derived from a base class, and are being dynamically allocated and stored.

For example, I have something like:

    vector&lt;Enemy*&gt; Enemies;

and I&#39;ll be deriving from the Enemy class and then dynamically allocating memory for the derived class, like this:

    enemies.push_back(new Monster());

What are things I need to be aware of to avoid memory leaks and other problems?

How to avoid memory leaks when using a vector of pointers to dynamically allocated objects in C++?

How does one go about sorting a vector containing custom (i.e. user defined) objects.  
Probably, standard STL algorithm **sort** along with a predicate (a function or a function object) which would operate on one of the fields (as a key for sorting) in the custom object should be used.  
Am I on the right track?

Sorting a vector of custom objects

I need to read a password from standard input and wanted `std::cin` not to echo the characters typed by the user...

How can I disable the echo from std::cin?

here is the code that I&#39;m currently using:

    string passwd;
    cout &lt;&lt; &quot;Enter the password: &quot;;
    getline( cin, passwd );

I&#39;m looking for a OS agnostic way to do this.
[Here](http://www.codeguru.com/forum/showthread.php?t=466009) there are ways to do this in both Windows and *nix. 

Reading a password from std::cin

What is the difference between the two? I mean the methods are all the same. So, for a user, they work identically. 

Is that correct??

What&#39;s the difference between deque and list STL containers?

Is there a way to iterate over the keys, not the pairs of a C++ map?

Iterate keys in a C++ map

I need to copy `std::set` to `std::vector`:

    std::set &lt;double&gt; input;
    input.insert(5);
    input.insert(6);
	
    std::vector &lt;double&gt; output;
    std::copy(input.begin(), input.end(), output.begin()); //Error: Vector iterator not dereferencable

Where is the problem?

C++, copy set to vector

I have been trying to find the intersection between two std::set in C++, but I keep getting an error.

I created a small sample test for this

    #include &lt;iostream&gt;
    #include &lt;vector&gt;
    #include &lt;algorithm&gt;
    #include &lt;set&gt;
    using namespace std;

    int main() {
      set&lt;int&gt; s1;
      set&lt;int&gt; s2;

      s1.insert(1);
      s1.insert(2);
      s1.insert(3);
      s1.insert(4);

      s2.insert(1);
      s2.insert(6);
      s2.insert(3);
      s2.insert(0);

      set_intersection(s1.begin(),s1.end(),s2.begin(),s2.end());
      return 0;
    }

The latter program does not generate any output, but I expect to have a new set (let&#39;s call it `s3`) with the following values:

    s3 = [ 1 , 3 ]

Instead, I&#39;m getting the error:

    test.cpp: In function ‘int main()’:
    test.cpp:19: error: no matching function for call to ‘set_intersection(std::_Rb_tree_const_iterator&lt;int&gt;, std::_Rb_tree_const_iterator&lt;int&gt;, std::_Rb_tree_const_iterator&lt;int&gt;, std::_Rb_tree_const_iterator&lt;int&gt;)’

What I understand out of this error, is that there&#39;s no definition in `set_intersection` that accepts `Rb_tree_const_iterator&lt;int&gt;` as a parameter. 

Furthermore, I  suppose the `std::set.begin()` method returns an object of such type, 

Is there a better way to find the intersection of two `std::set` in C++? Preferably a built-in function? 

How to find the intersection of two STL sets?

I&#39;m heavily using `std::set&lt;int&gt;` and often I simply need to check if such a set contains a number or not.

I&#39;d find it natural to write:

    if (myset.contains(number))
       ...

    
But because of the lack of a `contains` member, I need to write the cumbersome:

    if (myset.find(number) != myset.end())
      ..

or the not as obvious:

    if (myset.count(element) &gt; 0) 
      ..

Is there a reason for this design decision ?


Content Type	Original Author	Original Content on Stackoverflow
Question	leeeroy	View Question on Stackoverflow
Solution 1 - C++	CTT	View Answer on Stackoverflow
Solution 2 - C++	Darryl	View Answer on Stackoverflow
Solution 3 - C++	Andrew Hare	View Answer on Stackoverflow
Solution 4 - C++	Naveen	View Answer on Stackoverflow
Solution 5 - C++	Baris Ulgen	View Answer on Stackoverflow
Solution 6 - C++	arafat almubarok	View Answer on Stackoverflow

How do I find the largest int in a std::set<int>?

C++ Problem Overview

C++ Solutions

Solution 1 - C++

Solution 2 - C++

Solution 3 - C++

Solution 4 - C++

Solution 5 - C++

Solution 6 - C++

How can I tell, with something like objdump, if an object file has been built with -fPIC?

A better way to splice an array into an array in javascript

Attributions