It&#39;s compiler dependent.   That said, in general using `&quot;` prioritizes headers in the current working directory over system headers.  `&lt;&gt;` usually is used for system headers.  From to the specification (Section 6.10.2):

&gt;A preprocessing directive of the form

&gt;       # include &lt;h-char-sequence&gt; new-line
searches a sequence of implementation-defined places for a header identified uniquely by the specified sequence between the `&lt;` and `&gt;` delimiters, and causes the replacement of that directive by the entire contents of the header. How the places are specified or the header identified is implementation-defined.

&gt;A preprocessing directive of the form

&gt;       # include &quot;q-char-sequence&quot; new-line
causes the replacement of that directive by the entire contents of the source file identified by the specified sequence between the `&quot;` delimiters. The named source file is searched for in an implementation-defined manner. If this search is not supported, or if the search fails, the directive is reprocessed as if it read

&gt;       # include &lt;h-char-sequence&gt; new-line
&gt; with the identical contained sequence (including `&gt;` characters, if any) from the original
directive.    
    
So on *most* compilers, using the `&quot;&quot;` first checks your local directory, and if it doesn&#39;t find a match then moves on to check the system paths.  Using `&lt;&gt;` starts the search with system headers.

When you use angle brackets, the compiler searches for the file in the include path list. When you use double quotes, it first searches the current directory (i.e. the directory where the module being compiled is) and only then it&#39;ll search the include path list.

So, by convention, you use the angle brackets for standard includes and the double quotes for everything else. This ensures that in the (not recommended) case in which you have a local header with the same name as a standard header, the right one will be chosen in each case.

I’d like to make the browser to scroll the page to a given anchor, just by using JavaScript.

I have specified a `name` or `id` attribute in my HTML code:

     &lt;a name=&quot;anchorName&quot;&gt;..&lt;/a&gt;

or

     &lt;h1 id=&quot;anchorName2&quot;&gt;..&lt;/h1&gt;

I’d like to get the same effect as you’d get by navigating to `http://server.com/path#anchorName`. The page should be scrolled so that the anchor is near the top of the visible part of the page.




How to scroll an HTML page to a given anchor

I am aware that you can initialize an array during instantiation as follows:

    String[] names = new String[] {&quot;Ryan&quot;, &quot;Julie&quot;, &quot;Bob&quot;};

Is there a way to do the same thing with an ArrayList? Or must I add the contents individually with `array.add()`?

ArrayList initialization equivalent to array initialization

&gt; **Possible Duplicate:**  
&gt; [What is the difference between #include &amp;lt;filename&amp;gt; and #include “filename”?](https://stackoverflow.com/questions/21593/what-is-the-difference-between-include-filename-and-include-filename)  

&lt;!-- End of automatically inserted text --&gt;

What is the difference between angle bracket `&lt; &gt;` and double quotes `&quot; &quot;` while including header files in C++?

I mean which files are supposed to be included using eg: `#include &lt;QPushButton&gt;` and which files are to be included using eg: `#include &quot;MyFile.h&quot;`???

Difference between angle bracket &lt; &gt; and double quotes &quot; &quot; while including header files in C++?

> Possible Duplicate: 
> <a href="https://stackoverflow.com/questions/21593/what-is-the-difference-between-include-filename-and-include-filename" target="_blank" rel="noopener noreferrer">What is the difference between #include &#x3C;filename> and #include “filename”?</a>

What is the difference between angle bracket <code>&#x3C; ></code> and double quotes <code>" "</code> while including header files in C++?
I mean which files are supposed to be included using eg: <code>#include &#x3C;QPushButton></code> and which files are to be included using eg: <code>#include "MyFile.h"</code>???

How can I force a template parameter `T` to be a subclass of a specific class `Baseclass`?
Something like this:

    template &lt;class T : Baseclass&gt; void function(){
        T *object = new T();

    }


Restrict C++ Template Parameter to Subclass

I&#39;m using multitreading and want to merge the results. For example:

    std::vector&lt;int&gt; A;
    std::vector&lt;int&gt; B;
    std::vector&lt;int&gt; AB;

I want AB to have to contents of A and the contents of B in that order. What&#39;s the most efficient way of doing something like this?

What is the best way to concatenate two vectors?

How can I compile a C++ program with the GCC compiler?

### File *info.c*

    #include&lt;iostream&gt;
    using std::cout;
    using std::endl;

    int main()
    {
       #ifdef __cplusplus
       cout &lt;&lt; &quot;C++ compiler in use and version is &quot; &lt;&lt; __cplusplus &lt;&lt; endl;
       #endif
       cout &lt;&lt;&quot;Version is &quot; &lt;&lt; __STDC_VERSION__ &lt;&lt; endl;
       cout &lt;&lt; &quot;Hi&quot; &lt;&lt; __FILE__ &lt;&lt; __LINE__ &lt;&lt; endl;
    }

And when I try to compile `info.c`:

`gcc info.C`

```lang-none
Undefined                       first referenced
 symbol                             in file
cout                                /var/tmp/ccPxLN2a.o
endl(ostream &amp;)                     /var/tmp/ccPxLN2a.o
ostream::operator&lt;&lt;(ostream &amp;(*)(ostream &amp;))/var/tmp/ccPxLN2a.o
ostream::operator&lt;&lt;(int)            /var/tmp/ccPxLN2a.o
ostream::operator&lt;&lt;(long)           /var/tmp/ccPxLN2a.o
ostream::operator&lt;&lt;(char const *)   /var/tmp/ccPxLN2a.o
ld: fatal: Symbol referencing errors. No output written to a.out
collect2: ld returned 1 exit status
```

Isn&#39;t the GCC compiler capable of compiling C++ programs?
On a related note, what is the difference between `gcc` and `g++`?




Compiling a C++ program with GCC

Consider the following code:

    void foo()
    {
        {
            CSomeClass bar;
     
            // Some code here...
    
            goto label;
            
            // and here...
        }
    
    label:
        // and here...
    }
    
Will the destructor of bar be called ?

Goto out of a block: do destructors get called?

I&#39;m used to the Delphi VCL Framework, where TStreams throw exceptions on errors (e.g file not found, disk full). I&#39;m porting some code to use C++ STL instead, and have been caught out by iostreams NOT throwing exceptions by default, but setting [badbit/failbit flags][1] instead.

Two questions...

 a: Why is this - It seems an odd design decision for a language built with exceptions in it from day one?

 b: How best to avoid this? I could produce shim classes that throw as I would expect, but this feels like reinventing the wheel. Maybe there&#39;s a BOOST library that does this in a saner fashion?


  [1]: http://en.cppreference.com/w/cpp/io/ios_base/iostate

Why are C++ STL iostreams not &quot;exception friendly&quot;?

I have a `FILE *`, returned by a call to `fopen()`. I need to get a file descriptor from it, to make calls like `fsync(fd)` on it. What&#39;s the function to get a file descriptor from a file pointer?

How can I convert a file pointer ( FILE* fp ) to a file descriptor (int fd)?

I have the following

    size_t   i = 0;
    uint32_t k = 0;
    
    printf(&quot;i [ %lu ] k [ %u ]\n&quot;, i, k);
    
I get the following warning when compiling:
    
    format ‘%lu’ expects type ‘long unsigned int’, but argument has type ‘uint32_t’

When I ran this using splint I got the following:

    Format argument 1 to printf (%u) expects unsigned int gets size_t: k

Many thanks for any advice,


printf format specifiers for uint32_t and size_t

    int main()
    {
    
      enum Days{Sunday,Monday,Tuesday,Wednesday,Thursday,Friday,Saturday};
    
      Days TheDay;
    
      int j = 0;
    
      printf(&quot;Please enter the day of the week (0 to 6)\n&quot;);
    
      scanf(&quot;%d&quot;,&amp;j);
    
      TheDay = Days(j);
    
      //how to PRINT THE VALUES stored in TheDay
    
      printf(&quot;%s&quot;,TheDay);  //   isnt working
    
      return 0;
    }



Print text instead of value from C enum

What type for array index in C99 should be used? It have to work on LP32, ILP32, ILP64, LP64, LLP64 and more. It doesn&#39;t have to be a C89 type.

I have found 5 candidates:

* `size_t`
* `ptrdiff_t`
* `intptr_t` / `uintptr_t`
* `int_fast*_t` / `uint_fast*_t`
* `int_least*_t` / `uint_least*_t`

There is simple code to better illustrate problem. What is the best type for `i` and `j` in these two particular loops. If there is a good reason, two different types are fine too.

    for (i=0; i&lt;imax; i++) {
            do_something(a[i]);
    }
    /* jmin can be less than 0 */
    for (j=jmin; j&lt;jmax; j++) {
            do_something(a[j]);
    }

P.S.
In the first version of question I had forgotten about negative indexes.

P.P.S.
I am not going to write a C99 compiler. However any answer from a compiler programmer would be very valuable for me.

Similar question:

* https://stackoverflow.com/questions/1464174/size-t-vs-intptr-t  
The context of this question if different though.

What is the correct type for array indexes in C?

OK, so I don&#39;t sound like an idiot I&#39;m going to state the problem/requirements more explicitly:

 - Needle (pattern) and haystack (text to search) are both C-style null-terminated strings. No length information is provided; if needed, it must be computed.
 - Function should return a pointer to the first match, or `NULL` if no match is found.
 - **Failure cases are not allowed. This means any algorithm with non-constant (or large constant) storage requirements will need to have a fallback case for allocation failure (and performance in the fallback care thereby contributes to worst-case performance).**
 - Implementation is to be in C, although a good description of the algorithm (or link to such) without code is fine too.

...as well as what I mean by &quot;fastest&quot;:

 - Deterministic `O(n)` where `n` = haystack length. (But it may be possible to use ideas from algorithms which are normally `O(nm)` (for example rolling hash) if they&#39;re combined with a more robust algorithm to give deterministic `O(n)` results).
 - Never performs (measurably; a couple clocks for `if (!needle[1])` etc. are okay) worse than the naive brute force algorithm, especially on very short needles which are likely the most common case. (Unconditional heavy preprocessing overhead is bad, as is trying to improve the linear coefficient for pathological needles at the expense of likely needles.)
 - Given an arbitrary needle and haystack, comparable or better performance (no worse than 50% longer search time) versus any other widely-implemented algorithm.
 - Aside from these conditions, I&#39;m leaving the definition of &quot;fastest&quot; open-ended. A good answer should explain why you consider the approach you&#39;re suggesting &quot;fastest&quot;.

My current implementation runs in roughly between 10% slower and 8 times faster (depending on the input) than glibc&#39;s implementation of Two-Way.

**Update: My current optimal algorithm is as follows:**

 - For needles of length 1, use `strchr`.
 - For needles of length 2-4, use machine words to compare 2-4 bytes at once as follows: Preload needle in a 16- or 32-bit integer with bitshifts and cycle old byte out/new bytes in from the haystack at each iteration. Every byte of the haystack is read exactly once and incurs a check against 0 (end of string) and one 16- or 32-bit comparison.
 - For needles of length &gt;4, use Two-Way algorithm with a bad shift table (like Boyer-Moore) which is applied only to the last byte of the window. To avoid the overhead of initializing a 1kb table, which would be a net loss for many moderate-length needles, I keep a bit array (32 bytes) marking which entries in the shift table are initialized. Bits that are unset correspond to byte values which never appear in the needle, for which a full-needle-length shift is possible.

The big questions left in my mind are:

 - Is there a way to make better use of the bad shift table? Boyer-Moore makes best use of it by scanning backwards (right-to-left) but Two-Way requires a left-to-right scan.
 - The only two viable candidate algorithms I&#39;ve found for the general case (no out-of-memory or quadratic performance conditions) are [Two-Way](http://www-igm.univ-mlv.fr/~lecroq/string/node26.html) and [String Matching on Ordered Alphabets](http://www-igm.univ-mlv.fr/~lecroq/string/node27.html). But are there easily-detectable cases where different algorithms would be optimal? Certainly many of the `O(m)` (where `m` is needle length) in space algorithms could be used for `m&lt;100` or so. It would also be possible to use algorithms which are worst-case quadratic if there&#39;s an easy test for needles which provably require only linear time.

Bonus points for:

 - Can you improve performance by assuming the needle and haystack are both well-formed UTF-8? (With characters of varying byte lengths, well-formed-ness imposes some string alignment requirements between the needle and haystack and allows automatic 2-4 byte shifts when a mismatching head byte is encountered. But do these constraints buy you much/anything beyond what maximal suffix computations, good suffix shifts, etc. already give you with various algorithms?)

**Note:** I&#39;m well aware of most of the algorithms out there, just not how well they perform in practice. Here&#39;s a good reference so people don&#39;t keep giving me references on algorithms as comments/answers: http://www-igm.univ-mlv.fr/~lecroq/string/index.html

What is the fastest substring search algorithm?

If it even exists, what would a `std::map` extended initializer list look like?

I&#39;ve tried some combinations of... well, everything I could think of with GCC 4.4, but found nothing that compiled.


What would a std::map extended initializer list look like?

What is wrong with this program?

    #include &lt;memory&gt;
    #include &lt;vector&gt;
    
    int main()
    {
    	std::vector&lt;std::unique_ptr&lt;int&gt;&gt; vec;
    
    	int x(1);
    	std::unique_ptr&lt;int&gt; ptr2x(&amp;x);
    	vec.push_back(ptr2x); //This tiny command has a vicious error.
    
    	return 0;
    }

The error:

    In file included from c:\mingw\bin\../lib/gcc/mingw32/4.5.0/include/c++/mingw32/bits/c++allocator.h:34:0,
                     from c:\mingw\bin\../lib/gcc/mingw32/4.5.0/include/c++/bits/allocator.h:48,
                     from c:\mingw\bin\../lib/gcc/mingw32/4.5.0/include/c++/memory:64,
                     from main.cpp:6:
    c:\mingw\bin\../lib/gcc/mingw32/4.5.0/include/c++/bits/unique_ptr.h: In member function &#39;void __gnu_cxx::new_allocator&lt;_Tp&gt;::construct(_Tp*, const _Tp&amp;) [with _Tp = std::unique_ptr&lt;int&gt;, _Tp* = std::unique_ptr&lt;int&gt;*]&#39;:
    c:\mingw\bin\../lib/gcc/mingw32/4.5.0/include/c++/bits/stl_vector.h:745:6:   instantiated from &#39;void std::vector&lt;_Tp, _Alloc&gt;::push_back(const value_type&amp;) [with _Tp = std::unique_ptr&lt;int&gt;, _Alloc = std::allocator&lt;std::unique_ptr&lt;int&gt; &gt;, value_type = std::unique_ptr&lt;int&gt;]&#39;
    main.cpp:16:21:   instantiated from here
    c:\mingw\bin\../lib/gcc/mingw32/4.5.0/include/c++/bits/unique_ptr.h:207:7: error: deleted function &#39;std::unique_ptr&lt;_Tp, _Tp_Deleter&gt;::unique_ptr(const std::unique_ptr&lt;_Tp, _Tp_Deleter&gt;&amp;) [with _Tp = int, _Tp_Deleter = std::default_delete&lt;int&gt;, std::unique_ptr&lt;_Tp, _Tp_Deleter&gt; = std::unique_ptr&lt;int&gt;]&#39;
    c:\mingw\bin\../lib/gcc/mingw32/4.5.0/include/c++/ext/new_allocator.h:105:9: error: used here
    In file included from c:\mingw\bin\../lib/gcc/mingw32/4.5.0/include/c++/vector:69:0,
                     from main.cpp:7:
    c:\mingw\bin\../lib/gcc/mingw32/4.5.0/include/c++/bits/unique_ptr.h: In member function &#39;void std::vector&lt;_Tp, _Alloc&gt;::_M_insert_aux(std::vector&lt;_Tp, _Alloc&gt;::iterator, _Args&amp;&amp; ...) [with _Args = {const std::unique_ptr&lt;int&gt;&amp;}, _Tp = std::unique_ptr&lt;int&gt;, _Alloc = std::allocator&lt;std::unique_ptr&lt;int&gt; &gt;, std::vector&lt;_Tp, _Alloc&gt;::iterator = __gnu_cxx::__normal_iterator&lt;std::unique_ptr&lt;int&gt;*, std::vector&lt;std::unique_ptr&lt;int&gt; &gt; &gt;, typename std::vector&lt;_Tp, _Alloc&gt;::_Base::_Tp_alloc_type::pointer = std::unique_ptr&lt;int&gt;*]&#39;:
    c:\mingw\bin\../lib/gcc/mingw32/4.5.0/include/c++/bits/stl_vector.h:749:4:   instantiated from &#39;void std::vector&lt;_Tp, _Alloc&gt;::push_back(const value_type&amp;) [with _Tp = std::unique_ptr&lt;int&gt;, _Alloc = std::allocator&lt;std::unique_ptr&lt;int&gt; &gt;, value_type = std::unique_ptr&lt;int&gt;]&#39;
    main.cpp:16:21:   instantiated from here
    c:\mingw\bin\../lib/gcc/mingw32/4.5.0/include/c++/bits/unique_ptr.h:207:7: error: deleted function &#39;std::unique_ptr&lt;_Tp, _Tp_Deleter&gt;::unique_ptr(const std::unique_ptr&lt;_Tp, _Tp_Deleter&gt;&amp;) [with _Tp = int, _Tp_Deleter = std::default_delete&lt;int&gt;, std::unique_ptr&lt;_Tp, _Tp_Deleter&gt; = std::unique_ptr&lt;int&gt;]&#39;
    c:\mingw\bin\../lib/gcc/mingw32/4.5.0/include/c++/bits/vector.tcc:314:4: error: used here

Why can I not push_back a unique_ptr into a vector?

When a function takes a `shared_ptr` (from boost or C++11 STL), are you passing it:

  - by const reference: `void foo(const shared_ptr&lt;T&gt;&amp; p)`

  - or by value: `void foo(shared_ptr&lt;T&gt; p)` ?

I would prefer the first method because I suspect it would be faster. But is this really worth it or are there any additional issues?

Could you please give the reasons for your choice or if the case, why you think it does not matter.


Should we pass a shared_ptr by reference or by value?

`boost::tuple` has a `get()` member function used like this:

    tuple&lt;int, string, string&gt; t(5, &quot;foo&quot;, &quot;bar&quot;);
    cout &lt;&lt; t.get&lt;1&gt;();  // outputs &quot;foo&quot;

It seems the C++0x `std::tuple` does not have this member function, and you have to instead use the non-member function form:

    std::get&lt;1&gt;(t);

which to me looks uglier.

Is there any particular reason why `std::tuple` doesn&#39;t have the member function? Or is it just my implementation (GCC 4.4)?

std::tuple get() member function

I&#39;m wondering whether the tuple can be initialized by initializer list (to be more precise - by initializer_list of initializer_lists)? Considering the tuple definition:

    typedef std::tuple&lt; std::array&lt;short, 3&gt;,
                        std::array&lt;float, 2&gt;,
                        std::array&lt;unsigned char, 4&gt;,
                        std::array&lt;unsigned char, 4&gt; &gt; vertex;

is there any way of doing the following:

    static vertex const nullvertex = { {{0, 0, 0}},
                                       {{0.0, 0.0}},
                                       {{0, 0, 0, 0}},
                                       {{0, 0, 0, 0}} };

I just want to achieve same functionality I got using struct instead of tuple (thus only arrays are initialized by initializer_list):

    static struct vertex {
        std::array&lt;short, 3&gt; m_vertex_coords;
        std::array&lt;float, 2&gt; m_texture_coords;
        std::array&lt;unsigned char, 4&gt; m_color_1;
        std::array&lt;unsigned char, 4&gt; m_color_2;
    } const nullvertex = {
        {{0, 0, 0}},
        {{0.0, 0.0}},
        {{0, 0, 0, 0}},
        {{0, 0, 0, 0}}
    };

There is no reason I must use tuples, just wondering. I&#39;m asking, because I&#39;m unable to go through g++ templates errors which are generated by my attempt of such tuple initialization.

@Motti: So I missed the proper syntax for uniform initialization - 

    static vertex const nullvertex = vertex{ {{0, 0, 0}},
                                             {{0.0, 0.0}},
                                             {{0, 0, 0, 0}},
                                             {{0, 0, 0, 0}} };

and 

    static vertex const nullvertex{ {{0, 0, 0}},
                                    {{0.0, 0.0}},
                                    {{0, 0, 0, 0}},
                                    {{0, 0, 0, 0}} };

But it seems that all the trouble lies in arrays, which got no constructor for initializer_list and wrapping arrays with proper constructor seems not so easy task.

Content Type	Original Author	Original Content on Stackoverflow
Question	Sulla	View Question on Stackoverflow
Solution 1 - C++	Carl Norum	View Answer on Stackoverflow
Solution 2 - C++	Fabio Ceconello	View Answer on Stackoverflow

Difference between angle bracket < > and double quotes " " while including header files in C++?

C++ Problem Overview

C++ Solutions

Solution 1 - C++

Solution 2 - C++

ArrayList initialization equivalent to array initialization

How to scroll an HTML page to a given anchor

Attributions