(I assume) He just means that many, especially new, C++ programmers use `std::endl` blindly instead of `&#39;\n&#39;` for newline, flushing unnecessarily frequently and potentially making the performance of their program abysmal.

I.e., most people are taught that `std::endl` is **the** canonical way to insert a newline into a stream even though it is very rarely _necessary_ or appropriate to flush it.

It is some people&#39;s opinion (\*cough\*) that `std::endl` shouldn&#39;t even be in the standard, as it is so rarely appropriate and not a _significant_ typing savings over `&#39;\n&#39; &lt;&lt; std::flush` anyway.

---

**TL;DR**(s)**:**

 - In the end, `std::endl` buys you nothing except _usually worse_ performance and _usually more_ typing.
 - It has its uses, but they are considerably rarer than its frequency of use in most large codebases would suggest, therefore...
 - Its utility is highly questionable and its ubiquity is absurd – a fiasco indeed!

I&#39;m trying to use the cameras LED flashlight in a widget. I&#39;ve found several threads about this topic (i.e. [the one][1] mentioned later..) , now I&#39;m trying to control the light using:

    Camera cam = Camera.open(); 	
    Parameters p = cam.getParameters();
    p.setFlashMode(Parameters.FLASH_MODE_TORCH);
    cam.setParameters(p);
    cam.release();


In the AndroidManifest.xml tried different permissions, currently I have:

    &lt;uses-permission android:name=&quot;android.permission.CAMERA&quot; /&gt;
    &lt;uses-permission android:name=&quot;android.permission.FLASHLIGHT&quot;/&gt;
    &lt;uses-feature android:name=&quot;android.hardware.camera&quot; /&gt;
    &lt;uses-feature android:name=&quot;android.hardware.camera.autofocus&quot; /&gt;
    &lt;uses-feature android:name=&quot;android.hardware.camera.flash&quot; /&gt;

I&#39;m testing this on my Galaxy Tab as I don&#39;t have any other Android devices at hand: the light does not turn on. So I have a few questions now:

 1. Is there any way to test the led light behavior in the Emulator?
 2. Am I doing something wrong here?
 3. According to [this][2] question which deals with the same problem, it works differently on the Galaxy Tab. How?
 4. And finally, if it does work differently, I&#39;m starting to wonder if it&#39;s just the Galaxy Tab or if other devices use different methods too. It would be hard to test then and it seems rather odd to me.

Thanks for any insight!

By the way, I quickly tested with [quick-settings][3] which gets mentioned a few times here. The flashlight doesn&#39;t work with quick-settings either.

Note that the Galaxy Tab stil uses android 2.2. I see there were some changes between 2.2 and 2.3.

Comment:
I know it has to work somehow as I have found other apps in the market that work perfectly with the Galaxy Tab.

Comment 2: 
If I set cam.setParameters(p); and directly ask the camera for the current state with getFlashMode() it correctly returns FLASH_MODE_TORCH. However, if I release the camera and re-open it, it returns FLASH_MODE_OFF. It&#39;s almost as if the Camera object aknowledges the request but doesn&#39;t really pass it on to the hardware!?

--

After Konstantins comment, I removed the cam.release(); part. He is right, the settings are not persisted if you release the camera. If you use cam.open() again, you will get a fresh instance with the light off. The light&#39;s still not working on the galaxy tab though.
So, I guess it&#39;s hard to keep the light on if you&#39;re trying to control it through a widget then. As soon as the background service is finished, the camera object is released automatically and therefore the light switches off again. My questions still remain, especially why the camera doesn&#39;t switch on in the first place.

  [1]: https://stackoverflow.com/questions/5017455/how-to-use-camera-flash-led-as-torch-on-a-samsung-galaxy-tab
  [2]: https://stackoverflow.com/questions/5017455/how-to-use-camera-flash-led-as-torch-on-a-samsung-galaxy-tab
  [3]: http://code.google.com/p/quick-settings/

Use camera flashlight in Android

When I try to compile the piece of code below, I get this warning:

`warning: suggest parentheses around assignment used as truth value`

Why does this happen? This is a rather common idiom, I believe. I even use something like it earlier on my code.

    struct PIDList* 
    getRecordForPID(struct PIDList* list, pid_t pid) {
    	while(list = list-&gt;next)
    		if (list-&gt;pid == pid)
    			return list;
    
    	return NULL;
    }


Compiler warning - suggest parentheses around assignment used as truth value

I was listening to a [google talk by Andrei Alexandrescu on the D programming][1] language when he threw out a one liner about the &quot;endl&quot; fiasco. I just thought endl was the preferred way to signify the end of a line and flush the buffer for a stream. Why is it considered a fiasco? Should I not be using it in my code?


  [1]: http://www.youtube.com/watch?v=RlVpPstLPEc

What is the C++ iostream endl fiasco?

<p>I was listening to a <a href="http://www.youtube.com/watch?v=RlVpPstLPEc" target="_blank" rel="noopener noreferrer">google talk by Andrei Alexandrescu on the D programming</a> language when he threw out a one liner about the "endl" fiasco. I just thought endl was the preferred way to signify the end of a line and flush the buffer for a stream. Why is it considered a fiasco? Should I not be using it in my code?</p>


I was wondering about a quick to write implementation of a graph in c++. I need the data structure to be easy to manipulate and use graph algorithms(such as BFS,DFS, Kruskal, Dijkstra...).
I need this implementation for an algorithms Olympiad, so the easier to write the data structure the better.

Can you suggest such DS(main structs or classes and what will be in them). I know that an Adjacency list and Adjacency matrix are the main possibilities, but I mean a more detailed **code** sample.

For example I thought about this DS last time I had to implement a graph for DFS:

    struct Edge {
      int start;
      int end;
      struct Edge* nextEdge;
    }

and then used a array of size n containing in its i&#39;th place the Edge List(struct Edge) representing the edges starting in the i&#39;th node.

but when trying to DFS on this graph I had to write a 50 line code with about 10 while loops.

What &#39;good&#39; implementations are there?

Graph implementation C++

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

Short example:

    #include &lt;iostream&gt;

    int main()
    {
        int n;
        [&amp;](){n = 10;}();             // OK
        [=]() mutable {n = 20;}();    // OK
        // [=](){n = 10;}();          // Error: a by-value capture cannot be modified in a non-mutable lambda
        std::cout &lt;&lt; n &lt;&lt; &quot;\n&quot;;       // &quot;10&quot;
    }

The question: Why do we need the `mutable` keyword? It&#39;s quite different from traditional parameter passing to named functions. What&#39;s the rationale behind?

I was under the impression that the whole point of capture-by-value is to allow the user to change the temporary -- otherwise I&#39;m almost always better off using capture-by-reference, aren&#39;t I?

Any enlightenments?

(I&#39;m using MSVC2010 by the way. AFAIK this should be standard)


Why does C++11&#39;s lambda require &quot;mutable&quot; keyword for capture-by-value, by default?

Can someone please help me understand the following Morris inorder tree traversal algorithm without using stacks or recursion ? I was trying to understand how it works, but its just escaping me.
    
     1. Initialize current as root
     2. While current is not NULL
      If current does not have left child     
       a. Print current’s data
       b. Go to the right, i.e., current = current-&gt;right
      Else
       a. In current&#39;s left subtree, make current the right child of the rightmost node
       b. Go to this left child, i.e., current = current-&gt;left


I understand the tree is modified in a way that the `current node`, is made the `right child` of the `max node` in `right subtree` and use this property for inorder traversal. But beyond that, I&#39;m lost.

EDIT:
Found this accompanying c++ code. I was having a hard time to understand how the tree is restored after it is modified. The magic lies in `else` clause, which is hit once the right leaf is modified. See code for details:

	/* Function to traverse binary tree without recursion and
	   without stack */
	void MorrisTraversal(struct tNode *root)
	{
	  struct tNode *current,*pre;
	 
	  if(root == NULL)
		 return; 
	 
	  current = root;
	  while(current != NULL)
	  {
		if(current-&gt;left == NULL)
		{
		  printf(&quot; %d &quot;, current-&gt;data);
		  current = current-&gt;right;
		}
		else
		{
		  /* Find the inorder predecessor of current */
		  pre = current-&gt;left;
		  while(pre-&gt;right != NULL &amp;&amp; pre-&gt;right != current)
			pre = pre-&gt;right;
	 
		  /* Make current as right child of its inorder predecessor */
		  if(pre-&gt;right == NULL)
		  {
			pre-&gt;right = current;
			current = current-&gt;left;
		  }
		  
	 	 // MAGIC OF RESTORING the Tree happens here: 
		  /* Revert the changes made in if part to restore the original
			tree i.e., fix the right child of predecssor */
		  else
		  {
			pre-&gt;right = NULL;
			printf(&quot; %d &quot;,current-&gt;data);
			current = current-&gt;right;
		  } /* End of if condition pre-&gt;right == NULL */
		} /* End of if condition current-&gt;left == NULL*/
	  } /* End of while */
	}


Explain Morris inorder tree traversal without using stacks or recursion

To start you probably know that `const` can be used to make either an object&#39;s data or a pointer not modifiable or both.

```cpp
const Object* obj; // can&#39;t change data
Object* const obj; // can&#39;t change pointer
const Object* const obj; // can&#39;t change data or pointer
```

However you can also use the syntax:

```cpp
Object const *obj; // same as const Object* obj;
````

The only thing that seems to matter is which side of the asterisk you put the `const` keyword.  Personally I prefer to put `const` on the left of the type to specify it&#39;s data is not modifiable as I find it reads better in my left-to-right mindset but which syntax came first?

More importantly why is there two correct ways of specifying `const` data and in what situation would you prefer or need one over the other if any?

Edit:

So it sounds like this was an arbitrary decision when the standard for how compilers should interpret things was drafted long before I was born.  Since `const` is applied to what is to the left of the keyword (by default?) I guess they figured there was no harm in adding _&quot;shortcuts&quot;_ to apply keywords and type qualifiers in other ways at least until such a time as the declaration changes by parsing a * or &amp; ...

This was the case in C as well then I&#39;m assuming?


Const before or const after?

I just found a comment in [this][1] answer saying that using `iostream::eof` in a loop condition is &quot;almost certainly wrong&quot;. I generally use something like `while(cin&gt;&gt;n)` - which I guess implicitly checks for EOF.

Why is checking for eof explicitly using `while (!cin.eof())` wrong?  

How is it different from using `scanf(&quot;...&quot;,...)!=EOF` in C (which I often use with no problems)?


  [1]: https://stackoverflow.com/questions/5578631/c-how-do-you-stop-reading-integer-from-text-file-when-encounter-negative-intege/5578649#5578649

Why is iostream::eof inside a loop condition (i.e. `while (!stream.eof())`) considered wrong?

How can I print 0x0a, instead of 0xa using cout?

    #include  &lt;iostream&gt;
    
    using std::cout;  
    using std::endl;  
    using std::hex;
    
    int main()  
    {  
        cout &lt;&lt; hex &lt;&lt; showbase &lt;&lt; 10 &lt;&lt; endl;  
    }


How can I print 0x0a instead of 0xa using cout?

I&#39;m looking for a library which operates similar to iostreams, in that it performs conversions, and allows writing to memory buffers, files, and the console. However, I&#39;d like something type safe, as iostream is. Are there any serious libraries which do this?

Being able to specify the output encoding for things would be a plus.

Note that I&#39;m not interested in libraries which simply front iostreams because they just add *more* complexity to what iostreams is doing, e.g. `boost::format`.

PreEmptive comment response: I don&#39;t want to use cstdio because using that system it&#39;s impossible to have code be output location agnostic. That is, you have to call one function for sending things to buffers, and you have to call another function to send things to files, and another for the console, etc.

EDIT2: In response to the flurry of comments below: I&#39;m fed up with both iostreams and cstdio. Here are more specific reasons. I tried to keep my &quot;rant&quot; out of this question, but people keep asking my if I&#39;m off my rocker, so here&#39;s my rationale.

### cstdio

* Can&#39;t handle Unicode characters correctly
* Can&#39;t write into something like a string without doing manual buffer management
* Often requires support of nonstandard extensions (e.g. `vsnprintf`) in order to be usable (EDIT: Okay, C99&#39;s standard library being in C++11 adds most/all of these now)
* Can&#39;t change the location of output without changing the original code (nonstandard extensions e.g. in glibc allow you to treat a file pointer as a buffer, which kind of does this... but it&#39;s still just that, a nonstandard extension)
* Makes security &quot;fun&quot; (to the point where entire chapters are dedicated in security docs explaining issues, e.g. with &quot;printf&quot;&#39;s format strings and such)
* Not type safe

### iostreams

* Slow
* Entirely too complicated to a client. If you use only what comes with the standard library it&#39;s great, but attempting to extend things is next to impossible. I read the entire &quot;Standard C++ IOStreams and Locales&quot; book -- the only book seemingly available on the topic -- *twice* -- and I still don&#39;t know what&#39;s going on.

I love iostreams in concept, even the use of `operator&lt;&lt;` which some people seem to not like, but it seems entirely too over engineered to me. Someone should not have to spend countless hours reading books in order to be a simple client of your library. Sure, if you&#39;re adding a new output source or something like that I could understand, but.... clients should be shielded from that complexity. (Isn&#39;t that what a library&#39;s for?)

This is about the only thing that&#39;s painful in C++ that &quot;just works&quot; in other programming languages, that I see no reason to be complicated.

What serious alternatives exist for the IOStream library? (besides cstdio)

Is there a reason to use `endl` with `cout` when I can  just use `\n`? My C++ book says to use endl, but I don&#39;t see why. Is `\n` not supported as widely as `endl`, or am I missing something?



Why use endl when I can use a newline character?

I&#39;m following a college course about operating systems and we&#39;re learning how to convert from binary to hexadecimal, decimal to hexadecimal, etc. and today we just learned how signed/unsigned numbers are stored in memory using the two&#39;s complement (~number + 1).

We have a couple of exercises to do on paper and I would like to be able to verify my answers before submitting my work to the teacher. I wrote a C++ program for the first few exercises but now I&#39;m stuck as to how I could verify my answer with the following problem:

    char a, b;
    
    short c;
    a = -58;
    c = -315;
    
    b = a &gt;&gt; 3;

and we need to show the binary representation *in memory* of `a`, `b` and `c`.

I&#39;ve done it on paper and it gives me the following results (all the binary representations in memory of the numbers after the two&#39;s complement):

&gt; a = 00111010 (it&#39;s a char, so 1 byte)
&gt;
&gt; b = 00001000 (it&#39;s a char, so 1 byte)
&gt;
&gt; c = 11111110 11000101 (it&#39;s a short, so 2 bytes)

Is there a way to verify my answer? Is there a standard way in C++ to show the binary representation in memory of a number, or do I have to code each step myself (calculate the two&#39;s complement and then convert to binary)? I know the latter wouldn&#39;t take so long but I&#39;m curious as to if there is a standard way to do so.

Content Type	Original Author	Original Content on Stackoverflow
Question	Tod	View Question on Stackoverflow
Solution 1 - C++	ildjarn	View Answer on Stackoverflow

What is the C++ iostream endl fiasco?

C++ Problem Overview

C++ Solutions

Solution 1 - C++

Compiler warning - suggest parentheses around assignment used as truth value

Use camera flashlight in Android

Attributions