The `const` qualifier applies to the type to the immediate left unless there is nothing to the left then it applies to the type to the immediate right. So yup it&#39;s the same.

Contrived example:

    std::vector&lt;char*&gt; test;
    const auto a = test[0];
    *a = &#39;c&#39;;
    a = 0; // does not compile
    auto const b = test[1];
    *b = &#39;c&#39;;
    b = 0; // does not compile

Both `a` and `b` have type `char* const`. Don&#39;t think you can simply &quot;insert&quot; the type instead of the keyword `auto` (here: `const char* a`)! The `const` keyword will apply to the whole type that `auto` matches (here: `char*`).

I&#39;m using `:set showmatch` to highlight the matching bracket or brace when the cursor is over one. 

I&#39;d like to change the highlight-color so that it&#39;s radically different from the cursor color, because I&#39;ve got the situation shown in the screenshots. 

When the cursor is over the second brace:  
![Cursor over the second brace][1]

and when the cursor is to the immediate-right of the brace:  
![Cursor to the right][2]

This uses my terminal color scheme, which is taken from [Solarized](http://ethanschoonover.com/solarized). Unfortunately, it&#39;s a bit of a pain to see which highlight is the brace matching and which is the cursor, when the braces are close together. 

Is there a `vim` setting I can use to change the color of that to, say, the `bold magenta` ANSI? I&#39;m not particularly interested in remapping my ANSI colors within the terminal or shell - I&#39;d like a `vim`-specific option, if it exists. 




  [1]: http://i.stack.imgur.com/XzDe5.png
  [2]: http://i.stack.imgur.com/hUZCY.png

Set vim bracket highlighting colors

I am in the process of migrating an application from django 1.2 To 1.4.

I have a daily task object which contains a time of day that task should be completed:

    class DailyTask(models.Model):
        time = models.TimeField()
        last_completed = models.DateTimeField()
        name = models.CharField(max_length=100)
        description = models.CharField(max_length=1000)
        weekends = models.BooleanField()
        
        def __unicode__(self):
            return &#39;%s&#39; % (self.name)
            
        class Meta:
            db_table = u&#39;dailytask&#39;
            ordering = [&#39;name&#39;]

In order to check if a task is still required to be completed today, I have the following code:

    def getDueDailyTasks():
        dueDailyTasks=[]
        now = datetime.datetime.now()
        try:
            dailyTasks = DailyTask.objects.all()
        except dailyTask.DoesNotExist:
            return None
        for dailyTask in dailyTasks:
            timeDue = datetime.datetime(now.year,now.month,now.day,dailyTask.time.hour,dailyTask.time.minute,dailyTask.time.second)
            if timeDue&lt;now and timeDue&gt;dailyTask.last_completed:
                if dailyTask.weekends==False and now.weekday()&gt;4:
                    pass
                else:
                    dueDailyTasks.append({&#39;id&#39;:dailyTask.id,
                                &#39;due&#39;:timeDue,
                                 &#39;name&#39;: dailyTask.name,
                                 &#39;description&#39;:dailyTask.description})
        return dueDailyTasks

This worked fine under 1.2, But under 1.4 I get the error:

    can&#39;t compare offset-naive and offset-aware datetimes

due to the line

    if timeDue&lt;now and timeDue&gt;dailyTask.last_completed

and both comparison clauses throw this error.

I have tried making timeDue timezone aware by adding pytz.UTC as an argument, but this still raises the same error.

I&#39;ve read some of the docs on timezones but am confused as to whether I just need to make timeDue timezone aware, or whether I need to make a fundamental change to my db and existing data.

django 1.4 - can&#39;t compare offset-naive and offset-aware datetimes

Is there a semantic difference between `auto const` and `const auto`, or do they mean the same thing?


Is &#39;auto const&#39; and &#39;const auto&#39; the same?

<p>Is there a semantic difference between <code>auto const</code> and <code>const auto</code>, or do they mean the same thing?</p>


If have some code where I would like to use C++11x extensions as much as possible, but have a fallback if this is not supported. Currently the OSX version of GCC and the VisualC compiler has little to no support for C++11x, so I use:
    
    #if (defined(__APPLE__) || (defined(_WIN32)))
       ...fallback code without C++11x ...
    #else
       ... code using C++11x ...
    #endif

And this works, but is not really the right thing to do, especially since the gcc compiler in MacPorts DOES support c++11x.

Is there a `#define C11X_SUPPORTED` type macro? Perhaps something only GCC has?

Is there a preprocessor directive for detecting C++11x support?

Since `std::list` and `std::vector` exist, is there a reason to use traditional C arrays in C++, or should they be avoided, just like `malloc`?

Should arrays be used in C++?

Consider the following program which inserts a range of elements into a vector:

    vector&lt;string&gt; v1;
    vector&lt;string&gt; v2;
    
    v1.push_back(&quot;one&quot;);
    v1.push_back(&quot;two&quot;);
    v1.push_back(&quot;three&quot;);

    v2.push_back(&quot;four&quot;);
    v2.push_back(&quot;five&quot;);
    v2.push_back(&quot;six&quot;);
    
    v1.insert(v1.end(), v2.begin(), v2.end());

This efficiently copies the range, allocating enough space in the target vector for the entire range so that a maximum of one resize will be required.  Now consider the following program which attempts to move a range into a vector:

    vector&lt;string&gt; v1;
    vector&lt;string&gt; v2;
    
    v1.push_back(&quot;one&quot;);
    v1.push_back(&quot;two&quot;);
    v1.push_back(&quot;three&quot;);
    
    v2.push_back(&quot;four&quot;);
    v2.push_back(&quot;five&quot;);
    v2.push_back(&quot;six&quot;);
    
    for_each ( v2.begin(), v2.end(), [&amp;v1]( string &amp; s )
    {
    	v1.emplace_back(std::move(s));
    });

This performs a successful move but doesn&#39;t enjoy the benefits that insert() has with regard to preallocating space in the target vector, so the vector could be resized several times during the operation.  

So my question is, is there an insert equivalent which can move a range into a vector?

Is there a standard way of moving a range into a vector?

a.h

    #include &quot;logic.h&quot;
    ...
    
    class A
    {
    friend ostream&amp; operator&lt;&lt;(ostream&amp;, A&amp;);
    ...
    };

logic.cpp

    #include &quot;a.h&quot;
    ...
    ostream&amp; logic::operator&lt;&lt;(ostream&amp; os, A&amp; a)
    {
    ...
    }
    ...

When i compile, it says:

&gt; std::ostream&amp; logic::operator&lt;&lt;(std::ostream&amp;, A&amp;)&#39; must take exactly one argument.

What is the problem?

operator &lt;&lt; must take exactly one argument

I know that in C++11 we can now use `using` to write type alias, like `typedef`s:

    typedef int MyInt;

Is, from what I understand, equivalent to:

    using MyInt = int;

And that new syntax emerged from the effort to have a way to express &quot;template typedef&quot;:

    template&lt; class T &gt; using MyType = AnotherType&lt; T, MyAllocatorType &gt;;

But, with the first two non-template examples, are there any other subtle differences in the standard? For example, `typedef`s do aliasing in a &quot;weak&quot; way. That is it does not create a new type but only a new name (conversions are implicit between those names).

Is it the same with `using` or does it generate a new type? Are there any differences?

What is the difference between &#39;typedef&#39; and &#39;using&#39; in C++11?

The `noexcept` keyword can be appropriately applied to many function signatures, but I am unsure as to when I should consider using it in practice. Based on what I have read so far, the last-minute addition of `noexcept` seems to address some important issues that arise when move constructors throw. However, I am still unable to provide satisfactory answers to some practical questions that led me to read more about `noexcept` in the first place.

  1. There are many examples of functions that I know will never throw, but for which the compiler cannot determine so on its own. Should I append `noexcept` to the function declaration in **all such cases?** 

      Having to think about whether or not I need to append `noexcept` after **every** function declaration would greatly reduce programmer productivity (and frankly, would be a pain in the neck). For which situations should I be more careful about the use of `noexcept`, and for which situations can I get away with the implied `noexcept(false)`?

  2. When can I realistically expect to observe a performance improvement after using `noexcept`? In particular, give an example of code for which a C++ compiler is able to generate better machine code after the addition of `noexcept`.

      Personally, I care about `noexcept` because of the increased freedom provided to the compiler to safely apply certain kinds of optimizations. Do modern compilers take advantage of `noexcept` in this way? If not, can I expect some of them to do so in the near future?

When should I really use noexcept?

Doesn&#39;t `std::unique_ptr::get` defeat the purpose of having a unique_ptr in the first place?
I would have expected this function to change its state so it holds no more pointer.
Is there an actual useful use of std::unique_ptr::get?

what&#39;s the point of std::unique_ptr::get

If I declare an object wrapped in a shared pointer:

    std::shared_ptr&lt;myClass&gt; myClassObject(new myClass());
 
then I wanted to pass it as an argument to a method:

    DoSomething(myClassObject);
    
    //the called method
    void DoSomething(std::shared_ptr&lt;myClass&gt; arg1)
    {
       arg1-&gt;someField = 4;
    }

Does the above simply increment the shared_pt&#39;s reference count and everything is cool? Or does it leave a dangling pointer?

Are you still supposed to do this?:

    DoSomething(myClassObject.Get());
    
    void DoSomething(std::shared_ptr&lt;myClass&gt;* arg1)
    {
       (*arg1)-&gt;someField = 4;
    }

I think that the 2nd way may be more efficient because it only has to copy 1 address (as opposed to the whole smart pointer), but the 1st way seems more readable and I do not anticipate pushing performance limits. I just want to make sure there&#39;s not something dangerous about it.

Thank you.

Passing shared pointers as arguments

I was under the impression that accessing a `union` member other than the last one set is UB, but I can&#39;t seem to find a solid reference (other than answers claiming it&#39;s UB but without any support from the standard).

So, is it undefined behavior?

Accessing inactive union member and undefined behavior?

Came across an interesting interview question:

    test 1:
    printf(&quot;test %s\n&quot;, NULL);
    printf(&quot;test %s\n&quot;, NULL);
    
    prints:
    test (null)
    test (null)
    
    test 2:
    printf(&quot;%s\n&quot;, NULL);
    printf(&quot;%s\n&quot;, NULL);
    prints
    Segmentation fault (core dumped)
Though this might run fine on some systems, atleast mine is throwing a segmentation fault. 
What would be the best explanation of this behavior? Above code is in C.

Following is my gcc info:

    deep@deep:~$ gcc --version
    gcc (Ubuntu/Linaro 4.6.3-1ubuntu5) 4.6.3



What is the behavior of printing NULL with printf&#39;s %s specifier?

I had a lovely conversation with someone about the downfalls of `std::stoi`. To put it bluntly, it uses `std::strtol` internally, and throws if that reports an error. According to them, though, `std::strtol` shouldn&#39;t report an error for an input of `&quot;abcxyz&quot;`, causing `stoi` not to throw `std::invalid_argument`.

First of all, here are two programs tested on GCC about the behaviours of these cases:  
[strtol](http://ideone.com/6J6D7)  
[stoi](http://ideone.com/dHBcd)

Both of them show success on `&quot;123&quot;` and failure on `&quot;abc&quot;`. 

---

I looked in the standard to pull more info:

**&#167; 21.5**

&lt;!-- language: none --&gt;

    Throws: invalid_argument if strtol, strtoul, strtoll, or strtoull reports that  
    no conversion could be performed. Throws out_of_range if the converted value is  
    outside the range of representable values for the return type.

That sums up the behaviour of relying on `strtol`. Now what about `strtol`? I found this in the C11 draft:

**&#167;7.22.1.4**  

&lt;!-- language: none --&gt;

    If the subject sequence is empty or does not have the expected form, no  
    conversion is performed; the value of nptr is stored in the object  
    pointed to by endptr, provided that endptr is not a null pointer.

Given the situation of passing in `&quot;abc&quot;`, the C standard dictates that `nptr`, which points to the beginning of the string, would be stored in `endptr`, the pointer passed in. This seems consistent with the test. Also, 0 should be returned, as stated by this:

**&#167;7.22.1.4**  

&lt;!-- language: none --&gt;

    If no conversion could be performed, zero is returned.

The previous reference said that no conversion would be performed, so it must return 0. These conditions now comply with the C++11 standard for `stoi` throwing `std::invalid_argument`.

---

The result of this matters to me because I don&#39;t want to go around recommending `stoi` as a better alternative to other methods of string to int conversion, or using it myself as if it worked the way you&#39;d expect, if it doesn&#39;t catch text as an invalid conversion.

So after all of this, did I go wrong somewhere? It seems to me that I have good proof of this exception being thrown. Is my proof valid, or is `std::stoi` not guaranteed to throw that exception when given `&quot;abc&quot;`?


Is std::stoi actually safe to use?

Reading [this question](https://stackoverflow.com/q/11964089/20984) made me wonder: is there a technical reason for disallowing class templates overloads?

By overloading, I mean having several templates with the same names, but different parameters, for instance

    template &lt;typename T&gt;
    struct Foo {};

    template &lt;typename T1, typename T2&gt;
    struct Foo {};

    template &lt;unsigned int N&gt;
    struct Foo {};

The compiler manages to handle overloaded functions and function templates, wouldn&#39;t it be possible to apply the same techniques (e.g. name mangling) to class templates?

At first, I thought that perhaps that would cause some ambiguity issues when taking the template identifier alone, but the only time this can happen is when passing it as a template template argument, so the type of the parameter could be used to choose the appropriate overload:

    template &lt;template &lt;typename&gt; class T&gt;
    void A {};

    template &lt;template &lt;unsigned int&gt; class T&gt;
    void B {};

    A&lt;Foo&gt; a; // resolves to Foo&lt;T&gt;
    B&lt;Foo&gt; b; // resolves to Foo&lt;N&gt;

Do you think such feature could be useful? Is there some &quot;good&quot; (i.e. technical) reasons why this is not possible in current C++? 

Why is it not possible to overload class templates?

Per 7.5,

&gt; [errno] expands to a modifiable lvalue175) that has type int, the value of which is set to a positive error number by several library functions. It is unspecified whether errno is a macro or an identifier declared with external linkage. If a macro definition is suppressed in order to access an actual object, or a program defines an identifier with the name errno, the behavior is undefined.

&gt; 175) The macro errno need not be the identifier of an object. It might expand to a modifiable lvalue resulting from a function call (for example, *errno()).

It&#39;s not clear to me whether this is sufficient to require that `&amp;errno` not be a constraint violation. The C language has lvalues (such as register-storage-class variables; however these can only be automatic so `errno` could not be defined as such) for which the `&amp;` operator is a constraint violation.

If `&amp;errno` is legal C, is it required to be constant?


Is &amp;errno legal C?

How come constants cannot be set as properties of objects which are variables themselves?

    const a  = &#39;constant&#39; // all is well
    // set constant property of variable object
    const window.b = &#39;constant&#39; // throws Exception
    // OR
    var App = {};  // want to be able to extend
    const App.goldenRatio= 1.6180339887  // throws Exception


And how come constants passed by reference suddenly become variable?
EDIT: I know App won&#39;t (or rather... SHOULDN&#39;T) be mutable; this is just an observation...

    (function() {
        const App;
        // bunch of code
        window.com_namespace = App;
    }());
    window.com_namespace; // App
    window.com_namespace = &#39;something else&#39;;
    window.com_namespace; // &#39;something else&#39;

How can a nicely organized, extensible, object-oriented, singly namespaced library containing constants be made with these limitations?

EDIT:  I believe zi42, but I just have to ask [why][1]


  [1]: https://stackoverflow.com/questions/10843809/why-is-it-impossible-to-assign-constant-properties-of-javascript-objects-using-t

How to create Javascript constants as properties of objects using const keyword?

While writing the following function `abs`, I get the error:

non-member function `unsigned int abs(const T&amp;)` cannot have cv-qualifier.

    template&lt;typename T&gt;
    inline unsigned int abs(const T&amp; t) const
    {
        return t&gt;0?t:-t;
    }


After removing the `const` qualifier for the function there is no error. Since I am not modifying `t` inside the function the above code should have compiled. I am wondering why I got the error?





non-member function cannot have cv-qualifier

I&#39;m developing an android application which uses web service to get data from server, for that I&#39;m having three different set of URLs to point development system, test server and live server. It&#39;s difficult to change URL whenever I want to give application for testing/live. so I planned to make it as configurable, so that application can get appropriate URL based on me build type configuration constant. 
So, 

 - which is the best way to keep this constants, java static class or
   java public interface or xml resource file.? **When? Why?**
 - which gives better performance?, **When? Why?**

Ex: xml resource

    &lt;integer name=&quot;config_build_type&quot;&gt;0&lt;/integer&gt;
    &lt;string-array name=&quot;url_authentication&quot;&gt;
        &lt;item &gt;http://development.com/xxxx&lt;/item&gt;
        &lt;item &gt;http://test.com/xxx&lt;/item&gt;
        &lt;item &gt;http://example.com/xxx&lt;/item&gt;
    &lt;/string-array&gt;

Java static constant

    public class Config {
        public static final int BUILD_TYPE = 0; // 0 - development, 1 - test, 2 - live
        public static final String[] URL_AUTHENTICATION = {&quot;http://development.com/&quot;, &quot;http://test.com/&quot;, &quot;http://example.com&quot;};
    }


Which is best way to define constants in android, either static class, interface or xml resource?

I&#39;m new to Objective-C, and I have a few questions regarding `const` and the preprocessing directive `#define`.

First, I found that it&#39;s not possible to define the type of the constant using `#define`. Why is that?

Second, are there any advantages to use one of them over the another one?

Finally, which way is more efficient and/or more secure?


#define vs const in Objective-C

&gt; **Possible Duplicate:**  
&gt; [Is it possible to declare an array as constant](https://stackoverflow.com/questions/3803349/is-it-possible-to-declare-an-array-as-constant)  

&lt;!-- End of automatically inserted text --&gt;

Is it possible to use an array as a class constant in [PHP][1]?

I.e 

    const MYARRAY = array(&#39;123&#39;, &#39;234&#39;);

If not why?


  [1]: http://www.php.net/

PHP - use array as class constant

C++11 supports a new function syntax:

    auto func_name(int x, int y) -&gt; int;

Currently this function would be declared as:

    int func_name(int x, int y);

The new style does not seem to be widely adopted yet (say in the gcc stl)

However, should this new style be preferred everywhere in new C++11-programs, or will it only be used when needed?

Personally, I prefer the old style when possible, but a code-base with mixed styles looks pretty ugly.

Should the trailing return type syntax style become the default for new C++11 programs?

Does C++11 allow declaring non-static data members as &#39;auto&#39; if they are initialized in the declaration? For example:

    struct S
    {
        auto x = 5;  // in place of &#39;int x = 5;&#39;, which is definitely allowed
    };

GCC 4.7 rejects the above code, while it accepts `int x = 5;`.

Assuming this is not a compiler bug but rather the standard really doesn&#39;t allow it, why not? It would be just as useful as declaring local variables `auto`.

C++11 - declaring non-static data members as &#39;auto&#39;

Given my variable being a pointer, if I assign it to a variable of &quot;auto&quot; type, do I specify the &quot;*&quot; ?

    std::vector&lt;MyClass&gt; *getVector(); //returns populated vector
    //...

    std::vector&lt;MyClass&gt; *myvector = getVector();  //assume has n items in it
    auto newvar1 = myvector;

    // vs:
    auto *newvar2 = myvector;

    //goal is to behave like this assignment:
    std::vector&lt;MyClass&gt; *newvar3 = getVector();

I&#39;m a bit confused on how this `auto` works in c++11 (this is a new feature to c++11, right?)

**Update:** I revised the above to better clarify how my vector is really populated in a function, and I&#39;m just trying to assign the returned pointer to a variable.  Sorry for the confusion

Does &#39;auto&#39; type assignments of a pointer in c++11 require &#39;*&#39;?

If you read code like

`auto&amp;&amp; var = foo();`

where `foo` is any function returning by value of type `T`. Then `var` is an lvalue of type rvalue reference to `T`. But what does this imply for `var`? Does it mean, we are allowed to steal the resources of `var`? Are there any reasonable situations when you should use `auto&amp;&amp;` to tell the reader of your code something like you do when you return a `unique_ptr&lt;&gt;` to tell that you have exclusive ownership? And what about for example `T&amp;&amp;` when `T` is of class type?

I just want to understand, if there are any other use cases of `auto&amp;&amp;` than those in template programming; like the ones discussed in the examples in this article [Universal References][1] by Scott Meyers.


  [1]: http://isocpp.org/blog/2012/11/universal-references-in-c11-scott-meyers

What does auto&amp;&amp; tell us?

I was somehow surprised that the following code compiles and runs (vc2012 &amp; gcc4.7.2)

    class Foo {
        struct Bar { int i; };
    public:
        Bar Baz() { return Bar(); }
    };

    int main() {
        Foo f;
        // Foo::Bar b = f.Baz();  // error
        auto b = f.Baz();         // ok
        std::cout &lt;&lt; b.i;
    }

Is it correct that this code compiles fine? And why is it correct? Why can I use `auto` on a private type, while I can&#39;t use its name (as expected)?

Content Type	Original Author	Original Content on Stackoverflow
Question	steffen	View Question on Stackoverflow
Solution 1 - C++	AJG85	View Answer on Stackoverflow
Solution 2 - C++	AndiDog	View Answer on Stackoverflow

Is 'auto const' and 'const auto' the same?

C++ Problem Overview

C++ Solutions

Solution 1 - C++

Solution 2 - C++

django 1.4 - can't compare offset-naive and offset-aware datetimes

Set vim bracket highlighting colors

Attributions