You should include the `vector` header:

    #include &lt;vector&gt;


`#include &lt;vector&gt;` does not worked when I use Clang, I do not really know if it is a difference in C++ versions or libraries.

`#include &lt;set&gt;` does the trick.

Is there any good wrapper available for level based logging in golang?
If not, how should I go about implementing one myself?

What I want is pretty simple. I want a few functions e.g.

    log.Error()
    log.Info()

etc that display their outputs to stdout as well as save these in a log file (based on the level given to the program as commandline argument).
How do I implement this wrapper?

How to implement level based logging in golang?

I need to expose the &quot;*is mapped?*&quot; state of an instance of a class.  The outcome is determined by a basic check. It is **not** simply exposing the value of a field.  I am unsure as to whether I should use a read-only property or a method.

**Read-only property:**

    public bool IsMapped
    {
        get
        {
            return MappedField != null;
        }
    }

**Method:**

    public bool IsMapped()
    {
        return MappedField != null;
    }

I have read MSDN&#39;s [Choosing Between Properties and Methods][1] but I am still unsure.


  [1]: http://msdn.microsoft.com/en-us/library/vstudio/ms229054%28v=vs.100%29.aspx

To use a read-only property or a method?

I am developing a C++ application using CodeBlocks 10.05 on Debian 7.0.0.

For some reason, the following code


    #include &lt;iostream&gt;

    std::vector&lt; int &gt; delaunayDiv(const std::vector&lt; int &lt;T&gt; &gt; &amp; vP, cv::Rect boundRect,
        std::vector&lt;int&gt;&amp; triangles, int&amp; numTriangles, bool lookRight);

returns the following error

    error: &#39;vector&#39; in namespace &#39;std&#39; does not name a type


&#39;vector&#39; in namespace &#39;std&#39; does not name a type

I am developing a C++ application using CodeBlocks 10.05 on Debian 7.0.0.
For some reason, the following code
<pre><code class="hljs language-c">#include &#x3C;iostream>

std::vector&#x3C; int > delaunayDiv(const std::vector&#x3C; int &#x3C;T> > &#x26; vP, cv::Rect boundRect,
 std::vector&#x3C;int>&#x26; triangles, int&#x26; numTriangles, bool lookRight);
</code></pre>
returns the following error
<pre><code class="hljs language-go">error: 'vector' in namespace 'std' does not name a type
</code></pre>

I have a class called `Writer` that has a function `writeVector` like so:

    void Drawer::writeVector(vector&lt;T&gt; vec, bool index=true)
    {
        for (unsigned int i = 0; i &lt; vec.size(); i++) {
            if (index) {
                cout &lt;&lt; i &lt;&lt; &quot;\t&quot;;
            }
            cout &lt;&lt; vec[i] &lt;&lt; &quot;\n&quot;;
        }
    }

I&#39;m trying not to have a duplicate code, while still worrying about the performance.
In the function, I&#39;m doing the `if (index)` check on every round of my `for`-loop, even though the result is always the same.
This is against &quot;worrying about the performance&quot;.

I could easily avoid this by placing the check outside of my `for`-loop.
However, I&#39;ll get loads of duplicate code:

    void Drawer::writeVector(...)
    {
        if (index) {
            for (...) {
                cout &lt;&lt; i &lt;&lt; &quot;\t&quot; &lt;&lt; vec[i] &lt;&lt; &quot;\n&quot;;
            }
        }
        else {
            for (...) {
                cout &lt;&lt; vec[i] &lt;&lt; &quot;\n&quot;;
            }
        }
    }

So these are both &quot;bad&quot; solutions for me.
What I&#39;ve been thinking, is two private functions, one of them outs the index and then calls the other.
The other one only outs the value.
However, I can&#39;t figure out how to use it with my program, I&#39;d still need the `if` check to see which one to call...

According to the problem, polymorphism seems like a correct solution.
But I can&#39;t see how should I use it here.
What would be the preferred way to solve this kind of problem?

This is not a real program, **I&#39;m just interested in learning how this kind of problem should be solved.**

Avoiding if statement inside a for loop?

I am reading through Anthony Williams&#39; &quot;C++ Concurrency in Action&quot; and in Chapter 5, which talks about the new multithreading-aware memory model and atomic operations, and he states:

&gt; In order to use `std::atomic&lt;UDT&gt;` for some  user-defined `UDT`, this type must have a _trivial_ copy assignment operator.

As I understand it, this means that we can use `std::atomic&lt;UDT&gt;` if the following returns true:

    std::is_trivially_copyable&lt;UDT&gt;::value

By this logic, we shouldn&#39;t be able to use `std::string` as a template argument for `std::atomic` and have it work correctly.

However, the following code compiles and runs with expected output:

    #include &lt;atomic&gt;
    #include &lt;thread&gt;
    #include &lt;iostream&gt;
    #include &lt;string&gt;

    int main()
    {
    	std::atomic&lt;std::string&gt; atomicString;
    
    	atomicString.store( &quot;TestString1&quot; );
    
    	std::cout &lt;&lt; atomicString.load() &lt;&lt; std::endl;
    
    	atomicString.store( &quot;TestString2&quot; );
    
    	std::cout &lt;&lt; atomicString.load() &lt;&lt; std::endl;
    
    	return 0;
    }

Is this a case of undefined behaviour which just happens to behave as expected?

Thanks in advance!

Does std::atomic&lt;std::string&gt; work appropriately?

Is there a way to set by default for all projects removing the precompiler secure warnings that come up when using functions like scanf(). I found that you can do it by adding a line in the project option or a `#define _CRT_SECURE_NO_WARNINGS` in the beginning of the code.

I find myself repeatedly creating new projects for solving programming contests and it is really annoying (and takes valuable time) to add:

    #ifdef _MSC_VER
    #define _CRT_SECURE_NO_WARNINGS
    #endif

In the beginning of the code, or to set it in the precompiler options every time I start a new project.

Remove secure warnings (_CRT_SECURE_NO_WARNINGS) from projects by default in Visual Studio

I try to understand how `std::unique_ptr` works and for that I found [this][1] document. The author starts from the following example:

    #include &lt;utility&gt;  //declarations of unique_ptr
    using std::unique_ptr;
    // default construction
    unique_ptr&lt;int&gt; up; //creates an empty object
    // initialize with an argument
    unique_ptr&lt;int&gt; uptr (new int(3));
    double *pd= new double;
    unique_ptr&lt;double&gt; uptr2 (pd);
    // overloaded * and -&gt;
    *uptr2 = 23.5;
    unique_ptr&lt;std::string&gt; ups (new std::string(&quot;hello&quot;));
    int len=ups-&gt;size();

What is confusing to me is that in this line

    unique_ptr&lt;int&gt; uptr (new int(3));

We use integer as an argument (between round brackets) and here

    unique_ptr&lt;double&gt; uptr2 (pd);

we used an pointer as an argument. Does it make any difference? 

What is also not clear to me, is how pointers, declared in this way will be different from the pointers declared in a &quot;normal&quot; way.

  [1]: http://www.codeguru.com/cpp/article.php/c17775/The-Smart-Pointer-That-Makes-Your-C-Applications-Safer--stduniqueptr.htm

How to declare std::unique_ptr and what is the use of it?

I would like to include a protocol definition file in another protocol file. For example:

    // base.proto:
    message P_EndPoint {
      required int32 id = 1;
      required string host = 2;
      required int32 port = 3;
    }
Then in another file:

    communication.proto:
    // somehow include `base.proto&#39;
    // ...
    message P_CommunicationProtocol {
      required CP_MessageType type = 1;
      optional int32 id = 2;
      optional P_EndPoint identity = 3;
      repeated P_EndPoint others = 4;
    }
    // ...

 (Note: developers.google.com is not available in my locale)

Splitting protocol buffer definitions into multiple .proto files

    ifstream f;
    f.open(fileName);

    if ( f.fail() )
    {
        // I need error message here, like &quot;File not found&quot; etc. -
        // the reason of the failure
    }

How to get error message as string?

How to get error message when ifstream open fails

What is the use of `using namespace std`? 

I&#39;d like to see explanation in Layman terms.

What is the use of &quot;using namespace std&quot;?

I have an application that is performing some processing on some images.

Given that I know the width/height/format etc. (I do), and thinking just about defining a buffer to store the pixel data:

Then, rather than using `new` and `delete []` on an `unsigned char*` and keeping a separate note of the buffer size, I&#39;m thinking of simplifying things by using a `std::vector`.

So I would declare my class something like this:


    #include &lt;vector&gt;

    class MyClass
    {
        // ... etc. ...

    public:
        virtual void OnImageReceived(unsigned char *pPixels, 
            unsigned int uPixelCount);

    private:
        std::vector&lt;unsigned char&gt; m_pImageBuffer;    // buffer for 8-bit pixels

        // ... etc. ...
    };

Then, when I received a new image (of some variable size - but don&#39;t worry about those details here), I can just resize the vector (if necessary) and copy the pixels:

    void MyClass::OnImageReceived(unsigned char *pPixels, unsigned int uPixelCount)
    {
        // called when a new image is available
        if (m_pImageBuffer.size() != uPixelCount)
        {
            // resize image buffer
            m_pImageBuffer.reserve(uPixelCount);
            m_pImageBuffer.resize(uPixelCount, 0);
        }

        // copy frame to local buffer
        memcpy_s(&amp;m_pImageBuffer[0], m_pImageBuffer.size(), pPixels, uPixelCount);

        // ... process image etc. ...
    }

This seems fine to me, and I like that fact that I don&#39;t have to worry about the memory management, but it raises some questions:

1. Is this a valid application of `std::vector` or is there a more suitable container?
2. Am I doing the right thing performance-wise by calling `reserve` *and* `resize`?
3. Will it *always* be the case that the underlying memory is consecutive so I can use `memcpy_s` as shown?

Any additional comment, criticism or advice would be very welcome.


Is it good practice to use std::vector as a simple buffer?

Why does the string returned by `ctime()` have a line feed (`0x0A`) as its final character?  For example, this code:

    #include &lt;iostream&gt;
    #include &lt;cstdlib&gt;
    
    int main(int argc, char* argv[])
    {
        time_t now;
        time(&amp;now);
        char* time_str = ctime(&amp;now);
        std::cout &lt;&lt; time_str &lt;&lt; &quot;why is this on a new line?&quot; &lt;&lt; std::endl;
        return 0;
    }

...produces the following output:
   
    $ ./time.exe
    Wed Oct 23 14:52:29 2013
    why is this on a new line?
    $ 

It&#39;s not a big deal; I can strip the final byte from the string, but why does `ctime()` put it there in the first place?

Why does the string returned by ctime() contain a line feed?

I have long assumed that for any empty `std::vector` *V*, `V.begin() == V.end()`. Yet I see nothing in the C++ specification that states this to *always* be true. Is it necessarily true or does it just happen to be true on most implementations?

Is begin() == end() for any empty() vector?

C++14 presents [`std::dynarray`][1]:

&gt; std::dynarray is a sequence container that encapsulates arrays with a
&gt; size that is fixed at construction and does not change throughout the
&gt; lifetime of the object.

`std::dynarray` must be allocated in run-time as same as `std::vector`.

So what are the benefits and the usage of `std::dynarray` while we can use `std::vector` which is more dynamic (and also re-sizable)?




  [1]: http://en.cppreference.com/w/cpp/container/dynarray

std::dynarray vs std::vector

I have the following Java code with several big arrays which never change their size. It runs in 1100 ms on my computer.

I implemented the same code in C++ and used `std::vector`.

The time of the C++ implementation which runs the exact same code is 8800 ms on my computer. What did I do wrong, so that it runs this slowly?

Basically the code does the following:

    for (int i = 0; i &lt; numberOfCells; ++i) {
            h[i] =  h[i] + 1;
            floodedCells[i] =  !floodedCells[i];
            floodedCellsTimeInterval[i] =  !floodedCellsTimeInterval[i];
            qInflow[i] =  qInflow[i] + 1;
    }

It iterates through different arrays with a size of around 20000.

You can find both implementations under the following links:

- Java: https://ideone.com/R8KqjT
- C++: https://ideone.com/Lu7RpE

(On ideone I could only run the loop 400 times instead of 2000 times because of the time limitation. But even here there is a difference of three times)

Java 8 times faster with arrays than std::vector in C++. What did I do wrong?

I&#39;m using a external library which at some point gives me a raw pointer to an array of integers and a size.

Now I&#39;d like to use `std::vector` to access and modify these values in place, rather than accessing them with raw pointers.

Here is an articifial example that explains the point:

    size_t size = 0;
	int * data = get_data_from_library(size);   // raw data from library {5,3,2,1,4}, size gets filled in
	
	std::vector&lt;int&gt; v = ????;                  // pseudo vector to be used to access the raw data
	
	std::sort(v.begin(), v.end());              // sort raw data in place

	for (int i = 0; i &lt; 5; i++)
	{
	  std::cout &lt;&lt; data[i] &lt;&lt; &quot;\n&quot;;             // display sorted raw data 
	}

Expected output:

	1
	2
	3
	4
	5


The reason is that I need to apply algorithms from `&lt;algorithm&gt;` (sorting, swaping elements etc.) on that data.

On the other hand changing the size of that vector would never be changed, so `push_back`, `erase`, `insert` are not required to work on that vector.

I could construct a vector based on the data from the library, use modify that vector and copying the data back to to library, but that would be two complete copies that I&#39;d like to avoid as the data set could be really big.

Content Type	Original Author	Original Content on Stackoverflow
Question	OtagoHarbour	View Question on Stackoverflow
Solution 1 - C++	taocp	View Answer on Stackoverflow
Solution 2 - C++	leandro souza rosa	View Answer on Stackoverflow

'vector' in namespace 'std' does not name a type

C++ Problem Overview

C++ Solutions

Solution 1 - C++

Solution 2 - C++

To use a read-only property or a method?

How to implement level based logging in golang?

Attributions