I think the previous answers are misleading.

`fstream` *is* a proper RAII object, it *does* close automatically at the end of the scope, and there is absolutely *no need whatsoever* to call `close` manually when closing at the end of the scope is sufficient.

In particular, it’s not a “best practice” and it’s not necessary to flush the output.

And while Drakosha is right that calling `close` gives you the possibility to check the fail bit of the stream, nobody does that, anyway.

In an ideal world, one would simply call `stream.exceptions(ios::failbit)` beforehand and handle the exception that is thrown in an `fstream`’s destructor. But unfortunately exceptions in destructors are a broken concept in C++ so that’s not a good idea.

So **if** you want to check the success of closing a file, do it manually (but only then).

To append to Amy Lee&#39;s answer, it&#39;s better to do it manually because this way you can check for errors too.

BTW, according to [&quot;close&quot; manpage][1]:

&gt; **Not checking the return value of
&gt; close() is a common but nevertheless
&gt; serious programming error**. It is quite
&gt; possible that errors on a previous
&gt; write(2) operation are first reported
&gt; at the final close(). Not checking the
&gt; return value when closing the file may
&gt; lead to silent loss of data. This can
&gt; especially be observed with NFS and
&gt; with disk quota.
&gt; 
&gt; **A successful close does not guarantee
&gt; that the data has been successfully
&gt; saved to disk**, as the kernel defers
&gt; writes. It is not common for a
&gt; filesystem to flush the buffers when
&gt; the stream is closed. If you need to
&gt; be sure that the data is physically
&gt; stored use fsync(2). (It will depend
&gt; on the disk hardware at this point.)


  [1]: http://linux.die.net/man/2/close

I think it&#39;s a good practice to close your fstream, cause you need to flush the buffer, that what i&#39;ve been told

I have not found a way to do this. Is it possible?

How can I use TypefaceSpan or StyleSpan with a custom Typeface?

Consider the following (fragile) JavaScript code:

    var img = new Image;
    img.src = &quot;data:image/png;base64,...&quot;; // Assume valid data

    // Danger(?) Attempting to use image immediately after setting src
    console.log( img.width, img.height );
    someCanvasContext.drawImage( img, 0, 0 );
    
    // Danger(?) Setting onload after setting src
    img.onload = function(){ console.log(&#39;I ran!&#39;); };

**The Question(s)**

* Should the image width and height be correct immediately?
* Should the canvas draw work immediately?
* Should the `onload` callback (set after the src was changed) be invoked?

**Experimental Tests**  
I created a [simple test page](http://phrogz.net/tmp/img_via_dataurl.html) with similar code. In Safari my first tests, both by opening the HTML page locally (`file:///` url) and loading it from my server, showed everything working: the height and width is correct, the canvas draw works, _and_ the `onload` also fires.

In Firefox v3.6 (OS X), loading the page after launching the browser shows that the height/width is not correct immediately after setting, `drawImage()` fails. (The `onload` handler does fire, however.) Loading the page again, however, shows the width/height being correct immediately after setting, and `drawImage()` working. It would appear that Firefox caches the contents of the data URL as an image and has it available immediately when used in the same session.

In Chrome v8 (OS X) I see the same results as in Firefox: the image is not available immediately, but takes some time to asynchronously &#39;load&#39; from the data URL.

In addition to experimental proof of what browsers the above does or does not work, I&#39;d really love links to specs on how this is supposed to behave. So far my Google-fu has not been up to the task.

**Playing It Safe**  
For those who don&#39;t understand why the above might be dangerous, know that you should use images like this to be safe:

    // First create/find the image
    var img = new Image;
    
    // Then, set the onload handler
    img.onload = function(){
      // Use the for-sure-loaded img here
    };

    // THEN, set the src
    img.src = &#39;...&#39;;

Should setting an image src to data URL be available immediately?

&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?

> Possible Duplicate: 
> <a href="https://stackoverflow.com/questions/748014/do-i-need-to-manually-close-a-ifstream" target="_blank" rel="noopener noreferrer">Do I need to manually close a ifstream?</a>

Do I need to call <code>fstream.close()</code> or is <code>fstream</code> a proper RAII object that closes the stream on destruction?
I have a local <code>std::ofstream</code> 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.

The question is how to convert wstring to string?

I have next example :

    #include &lt;string&gt;
    #include &lt;iostream&gt;
    
    int main()
    {
        std::wstring ws = L&quot;Hello&quot;;
        std::string s( ws.begin(), ws.end() );
    
      //std::cout &lt;&lt;&quot;std::string =     &quot;&lt;&lt;s&lt;&lt;std::endl;
        std::wcout&lt;&lt;&quot;std::wstring =    &quot;&lt;&lt;ws&lt;&lt;std::endl;
        std::cout &lt;&lt;&quot;std::string =     &quot;&lt;&lt;s&lt;&lt;std::endl;
    }

the output with commented out line is :

    std::string =     Hello
    std::wstring =    Hello
    std::string =     Hello

but without is only :

    std::wstring =    Hello

Is anything wrong in the example? Can I do the conversion like above?


**EDIT**

New example (taking into account some answers) is 

    #include &lt;string&gt;
    #include &lt;iostream&gt;
    #include &lt;sstream&gt;
    #include &lt;locale&gt;
    
    int main()
    {
        setlocale(LC_CTYPE, &quot;&quot;);
    
        const std::wstring ws = L&quot;Hello&quot;;
        const std::string s( ws.begin(), ws.end() );
    
        std::cout&lt;&lt;&quot;std::string =     &quot;&lt;&lt;s&lt;&lt;std::endl;
        std::wcout&lt;&lt;&quot;std::wstring =    &quot;&lt;&lt;ws&lt;&lt;std::endl;
    
        std::stringstream ss;
        ss &lt;&lt; ws.c_str();
        std::cout&lt;&lt;&quot;std::stringstream =     &quot;&lt;&lt;ss.str()&lt;&lt;std::endl;
    }

The output is :

    std::string =     Hello
    std::wstring =    Hello
    std::stringstream =     0x860283c

therefore the stringstream can not be used to convert wstring into string.

How to convert wstring into string?

In my application, I want to redirect the output that would normally go to the stdout stream to a function I define. I read that you *can* redirect stdio to a file, so why not to a function?

For example:

    void MyHandler( const char* data );
    
    //&lt;&lt;Magical redirection code&gt;&gt;

    printf( &quot;test&quot; );
    std::cout &lt;&lt; &quot;test&quot; &lt;&lt; std::endl;
    
    //MyHandler should have been called with &quot;test&quot; twice, at this point

- How can I achieve this / similar behaviour?

C++: Redirecting STDOUT

C++ inherited arrays from C where they are used virtually everywhere. C++ provides abstractions that are easier to use and less error-prone (`std::vector&lt;T&gt;` since C++98 and [`std::array&lt;T, n&gt;`](http://en.cppreference.com/w/cpp/container/array) since [C++11](https://en.wikipedia.org/wiki/C++11)), so the need for arrays does not arise quite as often as it does in C. However, when you read legacy code or interact with a library written in C, you should have a firm grasp on how arrays work.

This FAQ is split into five parts:

1. [arrays on the type level and accessing elements](https://stackoverflow.com/questions/4810668/)
2. [array creation and initialization](https://stackoverflow.com/questions/4984228/)
3. [assignment and parameter passing](https://stackoverflow.com/questions/4810672/)
4. [multidimensional arrays and arrays of pointers](https://stackoverflow.com/questions/4810676/)
5. [common pitfalls when using arrays](https://stackoverflow.com/questions/4810664/how-do-i-use-arrays-in-c/7439261#7439261)

If you feel something important is missing in this FAQ, write an answer and link it here as an additional part.

In the following text, &quot;array&quot; means &quot;C array&quot;, not the class template `std::array`. Basic knowledge of the C declarator syntax is assumed. Note that the manual usage of `new` and `delete` as demonstrated below is extremely dangerous in the face of exceptions, but that is the topic of [another FAQ](https://stackoverflow.com/questions/712639/).

&lt;hr&gt;

_(Note: This is meant to be an entry to [Stack Overflow&#39;s C++ FAQ](https://stackoverflow.com/questions/tagged/c++-faq). If you want to critique the idea of providing an FAQ in this form, then [the posting on meta that started all this](https://meta.stackexchange.com/questions/68647/setting-up-a-faq-for-the-c-tag) would be the place to do that. Answers to that question are monitored in the [C++ chatroom](https://chat.stackoverflow.com/rooms/10/c-lounge), where the FAQ idea started out in the first place, so your answer is very likely to get read by those who came up with the idea.)_

How do I use arrays in C++?

I have legacy C++ code that I&#39;m supposed to remove unused code from. The problem is that the code base is large.

How can I find out which code is never called/never used?


How can I know which parts in the code are never used?

Do you have any good advice on how to avoid **circular dependencies of header files**, please?

Of course, from the beginning, I try to design the project as transparent as possible. However, as more and more features and classes are added, and the project gets less transparent, circular dependencies start happening.

**Are there any general, verified, and working rules?** Thanks.

Avoiding Circular Dependencies of header files

I need to sort an `std::map` by value rather than by key. Is there an easy way to do it?

I got one solution from the follwing thread:&lt;br/&gt;
https://stackoverflow.com/questions/3992874/stdmap-sort-by-data &lt;br/&gt;
Is there a better solution? &lt;br/&gt;

    map&lt;long, double&gt; testMap;
    // some code to generate the values in the map.
    
    sort(testMap.begin(), testMap.end());  // is there any function like this to sort the map?



Sorting std::map using value

I heard on a forum using `std::function&lt;&gt;` causes performance drop. Is it true? If true, is it a big performance drop?

What is the performance overhead of std::function?

Someone brought [this article][1] to my attention that claims *(I&#39;m paraphrasing)* the STL term is misused to refer to the entire C++ Standard Library instead of the parts that were taken from SGI STL.

&gt; (...) it refers to the &quot;STL&quot;, despite the fact that very few people still use the STL (which was designed at SGI).
&gt;
&gt; Parts of the C++ Standard Library were based on parts of the STL, and it is these parts that many people (including several authors and the notoriously error-ridden cplusplus.com) still refer to as &quot;the STL&quot;. However, this is inaccurate; indeed, the C++ standard never mentions &quot;STL&quot;, and there are content differences between the two.
&gt;
&gt; (...) &quot;STL&quot; is rarely used to refer to the bits of the stdlib that happen to be based on the SGI STL. People think it&#39;s the entire standard library. It gets put on CVs. And it is misleading.

I hardly know anything about C++&#39;s history so I can&#39;t judge the article&#39;s correctness. Should I refrain from using the term STL? Or is this an isolated opinion?


  [1]: http://kera.name/articles/2010/08/it-is-not-called-the-stl-mmkay/

What&#39;s the difference between &quot;STL&quot; and &quot;C++ Standard Library&quot;?

&gt; **Possible Duplicates:**  
&gt; [Why is &amp;#39;using namespace std;&amp;#39; considered a bad practice in C++?](https://stackoverflow.com/questions/1452721/why-is-using-namespace-std-considered-a-bad-practice-in-c)  
&gt; [Using std Namespace](https://stackoverflow.com/questions/1265039/using-std-namespace)  

&lt;!-- End of automatically inserted text --&gt;

Ive been hovering around a bunch of different forums and i seem to see this pop up every time and again. Its a very much beginner question.

I usually define a program with

    #include&lt;string&gt;
    using namespace std;

    string x;

I see a bunch of code samples out there who define a string as 
   
    std::string.

What is the purpose of this? is it good practice or have some functionality?




std::string vs string in c++

### game.cpp

&lt;!-- language: lang-cpp --&gt;

    #include &lt;iostream&gt;
    #include &lt;string&gt;
    #include &lt;sstream&gt;
    #include &quot;game.h&quot;
    #include &quot;board.h&quot;
    #include &quot;piece.h&quot;
    
    using namespace std;

### game.h

&lt;!-- language: lang-cpp --&gt;

    #ifndef GAME_H
    #define GAME_H
    #include &lt;string&gt;
    
    class Game
    {
    	private:
    		string white;
    		string black;
    		string title;
    	public:
    		Game(istream&amp;, ostream&amp;);
    		void display(colour, short);
    };
    
    #endif

---

The error is:

&gt; `game.h:8 error: &#39;string&#39; does not name a type`&lt;br&gt;
&gt; `game.h:9 error: &#39;string&#39; does not name a type`


Why am I getting string does not name a type Error?

`Implicit instantiation of undefined template &#39;std::basic_ifstream&lt;char,std::char_traits&lt;char&gt;&gt;&#39;`

---
    #ifndef MAPPER_H
    #define MAPPER_H
    #include &lt;iostream&gt;
    #include &lt;string&gt;
    #include &lt;vector&gt;
    #include &quot;KeyValue.h&quot;
    #include &quot;Parser.h&quot;
    
    using namespace std;
    class Mapper
    {
    public:
    	Mapper(ifstream&amp; infile);
    	~Mapper(void);
    	void loadTokens();
    	void showTokens();
    	void map();
    	void printMap();
    	void printMap(string map_fileName);
    private:
        ifstream inFile;  //&lt;-- is where the error is happening
    	vector&lt;string&gt; tokens;
    	vector&lt;KeyValue&gt; map_output;
    	Parser* parser;
    };
    
    #endif

I&#39;ve even tried putting `std::ifstream` and it still doesn&#39;t work.

When I `#include &lt;fstream&gt;` instead of `#include &lt;iostream&gt;`, I get these errors in `fstream.tcc` and `basic_ios.tcc`:

`&#39;operator=&#39; is a private member of &#39;std::basic_streambuf&lt;char&gt;&#39;`

And since that&#39;s part of the fstream library, obviously something i&#39;m doing is wrong...

Anyone able to help?

Why am I getting this ifstream error?

What&#39;s the difference between `ios::ate` and `ios:app` when writing to a file.  
In my view, `ios::app` gives you the ability to move around in the file, whereas with `ios::ate` it can only read/write at the end of the file. Is this correct?


C++ Filehandling: Difference between ios::app and ios::ate?

Can I get a file name or its path from a `fstream` object? I looked through the methods of `fstream` and didn&#39;t find anything close to it.

Getting filename (or path) from fstream

I have been hearing about streams, more specifically file streams.

So what are they?

Is it something that has a location in the memory?

Is it something that contains data?

Is it just a connection between a file and an object?


What is a stream in C++?

I have tested two writing configurations:

1. Fstream buffering:

    ```
    // Initialization
    const unsigned int length = 8192;
    char buffer[length];
    std::ofstream stream;
    stream.rdbuf()-&gt;pubsetbuf(buffer, length);
    stream.open(&quot;test.dat&quot;, std::ios::binary | std::ios::trunc)

    // To write I use :
    stream.write(reinterpret_cast&lt;char*&gt;(&amp;x), sizeof(x));
    ```

2. Manual buffering:

    ```
    // Initialization
    const unsigned int length = 8192;
    char buffer[length];
    std::ofstream stream(&quot;test.dat&quot;, std::ios::binary | std::ios::trunc);

    // Then I put manually the data in the buffer

    // To write I use :
    stream.write(buffer, length);
    ```

I expected the same result...

But my manual buffering improve performance by a factor of 10 to write a file of 100MB, and the fstream buffering does not change anything compared to the normal situation (without redefining a buffer).

Does someone has an explanation of this situation ?

EDIT :
Here are the news : a benchmark just done on a supercomputer (linux 64-bit architecture, lasts intel Xeon 8-core, Lustre filesystem and ... hopefully well configured compilers) 
![benchmark][1]
(and I don&#39;t explain the reason of the &quot;resonance&quot; for a 1kB manual buffer...)

EDIT 2 :
And the resonance at 1024 B (if someone has an idea about that, I&#39;m interested) :
![enter image description here][2]


  [1]: http://i.stack.imgur.com/NO8Pm.png
  [2]: http://i.stack.imgur.com/pknmv.png

std::fstream buffering vs manual buffering (why 10x gain with manual buffering)?

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	Tobias Langner	View Question on Stackoverflow
Solution 1 - C++	Konrad Rudolph	View Answer on Stackoverflow
Solution 2 - C++	Drakosha	View Answer on Stackoverflow
Solution 3 - C++	Amy Lee	View Answer on Stackoverflow

do I need to close a std::fstream?

C++ Problem Overview

C++ Solutions

Solution 1 - C++

Solution 2 - C++

Solution 3 - C++

Should setting an image src to data URL be available immediately?

How can I use TypefaceSpan or StyleSpan with a custom Typeface?

Attributions