You can do this, which doesn&#39;t need to create the string. It makes the output stream read out the contents of the stream on the right side (usable with any streams).

```lang-cpp
outFile &lt;&lt; ss.rdbuf();
```



If you are using `std::ostringstream` and wondering why nothing get written with `ss.rdbuf()` then use `.str()` function.



	outFile &lt;&lt; oStream.str();

When passing a stringstream rdbuf to a stream newlines are not translated.  The input text can contain `\n` so find replace won&#39;t work.  The old code wrote to an fstream and switching it to a stringstream losses the endl translation. 

I&#39;d rather write &lt;code&gt;ss.str();&lt;/code&gt; instead of &lt;code&gt;ss.rdbuf();&lt;/code&gt; (and use a stringstream).

If you use &lt;code&gt;ss.rdbuf()&lt;/code&gt; the format-flags of &lt;code&gt;outFile&lt;/code&gt; will be reset rendering your code non-reusable.
I.e., the caller of &lt;code&gt;GetHolesResults(..., std::ofstream &amp;outFile)&lt;/code&gt; might want to write something like this to display the result in a table:

    outFile &lt;&lt; std::setw(12) &lt;&lt; GetHolesResults ...

...and wonder why the width is ignored.

Given numbers like 499, 73433, 2348 what VBA can I use to round to the nearest 5 or 10? or an arbitrary number?

By 5:

     499 -&gt;  500
    2348 -&gt; 2350
    7343 -&gt; 7345

By 10:

     499 -&gt;  500
    2348 -&gt; 2350
    7343 -&gt; 7340

etc.


  [1]: http://blogs.msdn.com/ericlippert/archive/2003/09/26/bankers-rounding.aspx

Rounding a number to the nearest 5 or 10 or X

When you run `top` and see all running processes, I&#39;ve always wanted to know just what everything actually means.  e.g. all the various single-letter state codes for a running process (R = Running, S = Sleeping, etc...)

Where can I find this?


In Linux, what do all the values in the &quot;top&quot; command mean?

I&#39;m currently using `std::ofstream` as follows:

	std::ofstream outFile;
	outFile.open(output_file);

Then I attempt to pass a `std::stringstream` object to `outFile` as follows:

    GetHolesResults(..., std::ofstream &amp;outFile){
      float x = 1234;
      std::stringstream ss;
      ss &lt;&lt; x &lt;&lt; std::endl;
      outFile &lt;&lt; ss;
    }

Now my `outFile` contains nothing but garbage: &quot;0012E708&quot; repeated all over.

In `GetHolesResults` I can write 

    outFile &lt;&lt; &quot;Foo&quot; &lt;&lt; std:endl; 

and it will output correctly in `outFile`.

Any suggestion on what I&#39;m doing wrong?

Writing stringstream contents into ofstream

I'm currently using <code>std::ofstream</code> as follows:
<pre><code class="hljs language-c">std::ofstream outFile;
outFile.open(output_file);
</code></pre>
Then I attempt to pass a <code>std::stringstream</code> object to <code>outFile</code> as follows:
<pre><code class="hljs language-c">GetHolesResults(..., std::ofstream &#x26;outFile){
 float x = 1234;
 std::stringstream ss;
 ss &#x3C;&#x3C; x &#x3C;&#x3C; std::endl;
 outFile &#x3C;&#x3C; ss;
}
</code></pre>
Now my <code>outFile</code> contains nothing but garbage: "0012E708" repeated all over.
In <code>GetHolesResults</code> I can write
<pre><code class="hljs language-c">outFile &#x3C;&#x3C; "Foo" &#x3C;&#x3C; std:endl; 
</code></pre>
and it will output correctly in <code>outFile</code>.
Any suggestion on what I'm doing wrong?

When I discovered [`boost::lexical_cast`][1] I thought to myself &quot;why didn&#39;t I know about this sooner!&quot; - I hated having to write code like  

    stringstream ss;
    ss &lt;&lt; anIntVal;
    mystring = ss.str();

Now I write

    mystring = boost::lexical_cast&lt;string&gt;(anIntVal);

Yesterday, on stackoverflow, I came across boost split (another gem that will save me writing code).

    string stringtobesplit = &quot;AA/BB-CC&quot;)
    vector&lt;string&gt; tokens;
    
    boost::split(tokens, stringtobesplit, boost::is_any_of(&quot;/-&quot;)); 
    // tokens now holds 3 items: AA BB CC

I am going to start looking through boost documentation looking for other functions that I will be able to use regularly, but I feel that it will be very easy to miss things.  

What boost functions do you use most / would hate not to have? 


  [1]: http://www.boost.org/doc/libs/1_47_0/libs/conversion/lexical_cast.htm

Most used parts of Boost

A while ago, I had a discussion with a colleague about how to insert values in STL [maps][1]. I preferred `map[key] = value;` because it feels natural and is clear to read whereas he preferred `map.insert(std::make_pair(key, value))`.

I just asked him and neither of us can remember the reason why insert is better, but I am sure it was not just a style preference rather there was a technical reason such as efficiency. The [SGI STL reference][1] simply says: &quot;Strictly speaking, this member function is unnecessary: it exists only for convenience.&quot;

Can anybody tell me that reason, or am I just dreaming that there is one?

  [1]: http://www.sgi.com/tech/stl/Map.html

In STL maps, is it better to use map::insert than []?

If I have a function that needs to work with a `shared_ptr`, wouldn&#39;t it be more efficient to pass it a reference to it (so to avoid copying the `shared_ptr` object)?
What are the possible bad side effects?
I envision two possible cases:

1) inside the function a copy is made of the argument, like in

    ClassA::take_copy_of_sp(boost::shared_ptr&lt;foo&gt; &amp;sp)  
    {  
         ...  
         m_sp_member=sp; //This will copy the object, incrementing refcount  
         ...  
    }  

2) inside the function the argument is only used, like in  
    
    Class::only_work_with_sp(boost::shared_ptr&lt;foo&gt; &amp;sp) //Again, no copy here  
    {    
        ...  
        sp-&gt;do_something();  
        ...  
    }  

I can&#39;t see in both cases a good reason to pass the `boost::shared_ptr&lt;foo&gt;` by value instead of by reference. Passing by value would only &quot;temporarily&quot; increment the reference count due to the copying, and then decrement it when exiting the function scope.
Am I overlooking something?

Just to clarify, after reading several answers: I perfectly agree on the premature-optimization concerns, and I always try to first-profile-then-work-on-the-hotspots. My question was more from a purely technical code-point-of-view, if you know what I mean.

C++ - passing references to std::shared_ptr or boost::shared_ptr

I&#39;m a long time C++/Java developer trying to get into Python and am looking for the stereotypical &quot;Python for C++ Developers&quot; article, but coming up blank.  I&#39;ve seen these sort of things for C#, Java, etc, and they&#39;re incredibly useful for getting up to speed on language features and noteworthy differences.  Anyone have any references?

As a secondary bonus question, what open source Python program would you suggest looking at for clean design, commenting, and use of the language as a point of reference for study?

Thanks in advance.

Python for C++ Developers

This is a second-hand question from an OS development site, but it made me curious since I couldn&#39;t find a decent explanation anywhere.

When compiling and linking a free-standing C++ program using gcc, sometimes a linker error like this occurs:

    out/kernel.o:(.eh_frame+0x11): undefined reference to `__gxx_personality_v0&#39;

This is apparently because this symbol is defined in libstdc++, which is missing in a free-standing environment. Fixing the problem simply requires defining this symbol somewhere:

    void *__gxx_personality_v0;

Which is nice, but I don&#39;t like things that just magically work... So the question is, what is the purpose of this symbol?

What is __gxx_personality_v0 for?

I want to clear a element from a vector using the erase method. But the problem here is that the element is not guaranteed to occur only once in the vector. It may be present multiple times and I need to clear all of them. My code is something like this:

    void erase(std::vector&lt;int&gt;&amp; myNumbers_in, int number_in)
    {
        std::vector&lt;int&gt;::iterator iter = myNumbers_in.begin();
        std::vector&lt;int&gt;::iterator endIter = myNumbers_in.end();
        for(; iter != endIter; ++iter)
        {
            if(*iter == number_in)
            {
                myNumbers_in.erase(iter);
            }
        }
    }
    
    int main(int argc, char* argv[])
    {
        std::vector&lt;int&gt; myNmbers;
        for(int i = 0; i &lt; 2; ++i)
        {
            myNmbers.push_back(i);
            myNmbers.push_back(i);
        }
        
        erase(myNmbers, 1);
        
        return 0;
    }


This code obviously crashes because I am changing the end of the vector while iterating through it. What is the best way to achieve this? I.e. is there any way to do this without iterating through the vector multiple times or creating one more copy of the vector?

Erasing elements from a vector

Before I write my own I will ask all y&#39;all.

I&#39;m looking for a C++ class that is almost exactly like a STL vector but stores data into an array on the stack.  Some kind of STL allocator class would work also, but I am trying to avoid any kind of heap, even static allocated per-thread heaps (although one of those is my second choice).  The stack is just more efficient.

It needs to be almost a drop in replacement for current code that uses a vector.

For what I was about to write myself I was thinking of something like this:

    char buffer[4096];
    stack_vector&lt;match_item&gt; matches(buffer, sizeof(buffer));

Or the class could have buffer space allocated internally.  Then it would look like:

    stack_vector&lt;match_item, 256&gt; matches;

I was thinking it would throw std::bad_alloc if it runs out of space, although that should not ever happen.

**Update**

Using Chromium&#39;s stack_container.h works great!  

The reason I hadn&#39;t thought of doing it this way myself is that I have always overlooked the allocator object parameter to the STL collection constructors.  I have used the template parameter a few times to do static pools but I&#39;d never seen code or written any that actually used the object parameter.  I learned something new.  Very cool!

The code is a bit messy and for some reason GCC forced me to declare the allocator as an actual item instead of constructing it into vector&#39;s allocator parameter.  It went from something like this:

    typedef std::pair&lt; const char *, const char * &gt; comp_list_item;
    typedef std::vector&lt; comp_list_item &gt; comp_list_type;

    comp_list_type match_list;
    match_list.reserve(32);

To this:

    static const size_t comp_list_alloc_size = 128;
    typedef std::pair&lt; const char *, const char * &gt; comp_list_item;
    typedef StackAllocator&lt; comp_list_item, comp_list_alloc_size &gt; comp_list_alloc_type;
    typedef std::vector&lt; comp_list_item, comp_list_alloc_type &gt; comp_list_type;

    comp_list_alloc_type::Source match_list_buffer;
    comp_list_alloc_type match_list_alloc( &amp;match_list_buffer );
    comp_list_type match_list( match_list_alloc );
    match_list.reserve( comp_list_alloc_size );

And I have to repeat that whenever I declare a new one.  But it works just like I wanted.

I noticed that stack_container.h has a StackVector defined and I tried using it.  But it doesn&#39;t inherit from vector or define the same methods so it wasn&#39;t a drop-in replacement.  I didn&#39;t want to rewrite all the code using the vector so I gave up on it.

Looking for C++ STL-like vector class but using stack storage

I have a situation where I need to process large (many GB&#39;s) amounts of data as such:

1. build a large string by appending many smaller (C char*) strings
2. trim the string
3. convert the string into a C++ const std::string for processing (read only)
4. repeat

The data in each iteration are independent.

My question is, I&#39;d like to minimise (if possible eliminate) heap allocated memory usage, as it at the moment is my largest performance problem.

Is there a way to convert a C string (char*) into a stl C++ string (std::string) without requiring std::string to internally alloc/copy the data?

Alternatively, could I use stringstreams or something similar to re-use a large buffer?

**Edit:** Thanks for the answers, for clarity, I think a revised question would be:

*How can I build (via multiple appends) a stl C++ string efficiently. And if performing this action in a loop, where each loop is totally independant, how can I re-use thisallocated space.*


initializing std::string from char* without copy

What is the correct way of iterating over a vector in C++?

Consider these two code fragments, this one works fine:

    for (unsigned i=0; i &lt; polygon.size(); i++) {
        sum += polygon[i];
    }

and this one:

    for (int i=0; i &lt; polygon.size(); i++) {
        sum += polygon[i];
    }

which generates `warning: comparison between signed and unsigned integer expressions`.

I&#39;m new in the world of C++, so the `unsigned` variable looks a bit frightening to me and I know `unsigned` variables can be dangerous if not used correctly, so - is this correct?


Iteration over std::vector: unsigned vs signed index variable

I&#39;d like to call a function in python using a dictionary.

Here is some code:

    d = dict(param=&#39;test&#39;)
    
    def f(param):
        print(param)
    
    f(d)

This prints `{&#39;param&#39;: &#39;test&#39;}` but I&#39;d like it to just print `test`.

I&#39;d like it to work similarly for more parameters:

    d = dict(p1=1, p2=2)
    def f2(p1, p2):
        print(p1, p2)
    f2(d)


Is this possible?


Passing a dictionary to a function as keyword parameters

How do I parameterize a query containing an `IN` clause with a variable number of arguments, like this one?

    SELECT * FROM Tags 
    WHERE Name IN (&#39;ruby&#39;,&#39;rails&#39;,&#39;scruffy&#39;,&#39;rubyonrails&#39;)
    ORDER BY Count DESC

In this query, the number of arguments could be anywhere from 1 to 5.

I would prefer not to use a dedicated stored procedure for this (or XML), but if there is some elegant way specific to [SQL Server 2008][1], I am open to that.

  [1]: http://en.wikipedia.org/wiki/Microsoft_SQL_Server#SQL_Server_2008


Parameterize an SQL IN clause

I&#39;m creating HTML with a loop that has a column for Action. That column
is a Hyperlink that when the user clicks calls a JavaScript
function and passes the parameters...

example:

    &lt;a href=&quot;#&quot; OnClick=&quot;DoAction(1,&#39;Jose&#39;);&quot; &gt; Click &lt;/a&gt;
    &lt;a href=&quot;#&quot; OnClick=&quot;DoAction(2,&#39;Juan&#39;);&quot; &gt; Click &lt;/a&gt;
    &lt;a href=&quot;#&quot; OnClick=&quot;DoAction(3,&#39;Pedro&#39;);&quot; &gt; Click &lt;/a&gt;
    ...
    &lt;a href=&quot;#&quot; OnClick=&quot;DoAction(n,&#39;xxx&#39;);&quot; &gt; Click &lt;/a&gt;

I want that function to call an Ajax jQuery function with the correct
parameters.

Any help?


Passing parameters to a JQuery function

Can it be assumed a evaluation order of the function parameters when calling it in C ? According to the following program, it seems that there is not a particular order when I executed it. 

    #include &lt;stdio.h&gt;
    
    int main()
    {
       int a[] = {1, 2, 3};
       int * pa; 
    
       pa = &amp;a[0];
       printf(&quot;a[0] = %d\ta[1] = %d\ta[2] = %d\n&quot;,*(pa), *(pa++),*(++pa));
       /* Result: a[0] = 3	a[1] = 2    a[2] = 2 */
    
       pa = &amp;a[0];
       printf(&quot;a[0] = %d\ta[1] = %d\ta[2] = %d\n&quot;,*(pa++),*(pa),*(++pa));
       /* Result: a[0] = 2	a[1] = 2     a[2] = 2 */
    
       pa = &amp;a[0];
       printf(&quot;a[0] = %d\ta[1] = %d\ta[2] = %d\n&quot;,*(pa++),*(++pa), *(pa));
       /* a[0] = 2	a[1] = 2 a[2] = 1 */
    
    }

Parameter evaluation order before a function calling in C

I often find myself confused with how the terms &#39;arguments&#39; and &#39;parameters&#39; are used. They seem to be used interchangeably in the programming world.

What&#39;s the correct convention for their use?

Arguments or parameters?

How do I convert from `std::stringstream` to `std::string` in C++?

Do I need to call a method on the string stream?

How do I convert from stringstream to string in C++?

My question can be boiled down to, where does the string returned from `stringstream.str().c_str()` live in memory, and why can&#39;t it be assigned to a `const char*`?

This code example will explain it better than I can

    #include &lt;string&gt;
    #include &lt;sstream&gt;
    #include &lt;iostream&gt;
    
    using namespace std;
    
    int main()
    {
    	stringstream ss(&quot;this is a string\n&quot;);
    
    	string str(ss.str());
    
    	const char* cstr1 = str.c_str();
    
    	const char* cstr2 = ss.str().c_str();
    
    	cout &lt;&lt; cstr1	// Prints correctly
    		&lt;&lt; cstr2;	// ERROR, prints out garbage
    
    	system(&quot;PAUSE&quot;);
    	
    	return 0;
    }

The assumption that `stringstream.str().c_str()` could be assigned to a `const char*` led to a bug that took me a while to track down.

For bonus points, can anyone explain why replacing the `cout` statement with

    cout &lt;&lt; cstr            // Prints correctly
        &lt;&lt; ss.str().c_str() // Prints correctly
        &lt;&lt; cstr2;           // Prints correctly (???)

prints the strings correctly?

I&#39;m compiling in Visual Studio 2008.

stringstream, string, and char* conversion confusion

I recently discovered that `std::strstream` has been deprecated in favor of `std::stringstream`.  It&#39;s been a while since I&#39;ve used it, but it did what I needed to do at the time, so was surprised to hear of its deprecation.

My question is why was this decision made, and what benefits does `std::stringstream` provide that are absent from `std::strstream`?

Why was std::strstream deprecated?

I want to output an integer to a `std::stringstream` with the equivalent format of `printf`&#39;s `%02d`. Is there an easier way to achieve this than:

    std::stringstream stream;
    stream.setfill(&#39;0&#39;);
    stream.setw(2);
    stream &lt;&lt; value;

Is it possible to stream some sort of format flags to the `stringstream`, something like (pseudocode):

    stream &lt;&lt; flags(&quot;%02d&quot;) &lt;&lt; value;

Equivalent of %02d with std::stringstream?

    stringstream parser;
    
    parser &lt;&lt; 5;
    short top = 0;
    parser &gt;&gt; top;
    parser.str(&quot;&quot;); //HERE I&#39;M RESETTING parser
    
    parser &lt;&lt; 6; //DOESN&#39;T PUT 6 INTO parser
    short bottom = 0;
    parser &gt;&gt; bottom;

Why doesn&#39;t it work?

How to clear stringstream?

&gt; **Possible Duplicate:**  
&gt; [Do I need to manually close a ifstream?](https://stackoverflow.com/questions/748014/do-i-need-to-manually-close-a-ifstream)  

&lt;!-- End of automatically inserted text --&gt;

Do I need to call `fstream.close()` or is `fstream` a proper RAII object that closes the stream on destruction?

I have a local `std::ofstream` object inside a method. Can I assume that the file is always closed after exiting this method without calling close? I could not find documentation of the destructor.

do I need to close a std::fstream?

The contents of file.txt are:

    5 3
    6 4
    7 1
    10 5
    11 6
    12 3
    12 4

Where `5 3` is a coordinate pair.
How do I process this data line by line in C++?

I am able to get the first line, but how do I get the next line of the file?

    ifstream myfile;
    myfile.open (&quot;file.txt&quot;);

Read file line by line using ifstream in C++

I currently write a set of doubles from a vector to a text file like this:

	std::ofstream fout;
	fout.open(&quot;vector.txt&quot;);

	for (l = 0; l &lt; vector.size(); l++)
		fout &lt;&lt; std::setprecision(10) &lt;&lt; vector.at(l) &lt;&lt; std::endl;

	fout.close();

But this is taking a lot of time to finish. Is there a faster or more efficient way to do this? I would love to see and learn it. 


Content Type	Original Author	Original Content on Stackoverflow
Question	Eric	View Question on Stackoverflow
Solution 1 - C++	Johannes Schaub - litb	View Answer on Stackoverflow
Solution 2 - C++	Digital_Reality	View Answer on Stackoverflow
Solution 3 - C++	2ndshot	View Answer on Stackoverflow
Solution 4 - C++	chipsbarrier	View Answer on Stackoverflow

Writing stringstream contents into ofstream

C++ Problem Overview

C++ Solutions

Solution 1 - C++

Solution 2 - C++

Solution 3 - C++

Solution 4 - C++

In Linux, what do all the values in the "top" command mean?

Rounding a number to the nearest 5 or 10 or X

Attributions