After reading [Hidden Features and Dark Corners of C++/STL][1] on `comp.lang.c++.moderated`, I was completely surprised that the following snippet compiled and worked in both Visual Studio 2008 and G++ 4.4.

Here&#39;s the code:

    #include &lt;stdio.h&gt;
    int main()
    {
        int x = 10;
        while (x --&gt; 0) // x goes to 0
        {
            printf(&quot;%d &quot;, x);
        }
    }

Output:

    9 8 7 6 5 4 3 2 1 0

I&#39;d assume this is C, since it works in GCC as well. Where is this defined in the standard, and where has it come from?

  [1]: http://groups.google.com/group/comp.lang.c++.moderated/msg/33f173780d58dd20

What is the &quot;--&gt;&quot; operator in C/C++?

Using reflection on Java classes to access all field, methods, and so on:  
**Is there a standardized order of these elements** (which is specified in some standard)?

Of course, I **could** check it empirically, but I need to know if it&#39;s always
the same.

**EDIT:**  
*I waited for the question: What I need the order for ;)  
Long story short: I have JAXB-annotated classes, and want no
represent these classes visually. While the order of XML attributes 
is neither relevant for the XML
standard, nor for JAXB, I want to have a certain order the XML attributes for the 
visual representation.  
For example: start comes after end. This hurts one&#39;s intuition.*


Java reflection: Is the order of class fields and methods standardized?

Is this program well-defined, and if not, why exactly?

    #include &lt;iostream&gt;
    #include &lt;new&gt;
    struct X {
        int cnt;
        X (int i) : cnt(i) {}
        ~X() {  
                std::cout &lt;&lt; &quot;destructor called, cnt=&quot; &lt;&lt; cnt &lt;&lt; std::endl;
                if ( cnt-- &gt; 0 )
                    this-&gt;X::~X(); // explicit recursive call to dtor
        }
    };
    int main()
    {   
        char* buf = new char[sizeof(X)];
        X* p = new(buf) X(7);
        p-&gt;X::~X();  // explicit call to dtor
        delete[] buf;
    }

My reasoning: although [invoking a destructor twice is undefined behavior][1], per 12.4/14, what it says exactly is this:
&gt; the behavior is undefined if the
&gt; destructor is invoked for an object
&gt; whose lifetime has ended

Which does not seem to prohibit recursive calls. While the destructor for an object is executing, the object&#39;s lifetime has not yet ended, thus it&#39;s not UB to invoke the destructor again. On the other hand, 12.4/6 says:
&gt; After executing the body [...] a
&gt; destructor for class X calls the
&gt; destructors for X&#39;s direct members,
&gt; the destructors for X&#39;s direct base
&gt; classes [...]

which means that after the return from a recursive invocation of a destructor, all member and base class destructors will have been called, and calling them again when returning to the previous level of recursion would be UB. Therefore, a class with no base and only POD members can have a recursive destructor without UB. Am I right?

  [1]: https://stackoverflow.com/questions/2771567/why-exactly-is-calling-the-destructor-for-the-second-time-undefined-behavior-in-c


Can a destructor be recursive?

Example:
Is the following code valid against the [JSON Spec][1]?

    {
        precision: &quot;zip&quot;
    }

Or should I always use the following syntax? (And if so, why?)

    {
        &quot;precision&quot;: &quot;zip&quot;
    }

I haven&#39;t really found something about this in the JSON specifications. Although they use quotes around their keys in their examples.

  [1]: https://www.rfc-editor.org/rfc/rfc4627

Do the JSON keys have to be surrounded by quotes?

A simple test app:

    cout &lt;&lt; new int[0] &lt;&lt; endl;

outputs:

    0x876c0b8

So it looks like it works. What does the standard say about this? Is it always legal to &quot;allocate&quot; empty block of memory?



C++ new int[0] -- will it allocate memory?

Coderbyte is an online coding challenge site (I found it just 2 minutes ago).

[The first C++ challenge][1] you are greeted with has a C++ skeleton you need to modify:

&gt;     #include &lt;iostream&gt;
&gt;     #include &lt;string&gt;
&gt;     using namespace std;
&gt;
&gt;     int FirstFactorial(int num) {
&gt;
&gt;       // Code goes here
&gt;       return num;
&gt;
&gt;     }
&gt;
&gt;     int main() {
&gt;
&gt;       // Keep this function call here
&gt;       cout &lt;&lt; FirstFactorial(gets(stdin));
&gt;       return 0;
&gt;
&gt;     }

If you are little familiar with C++ the first thing&lt;sup&gt;*&lt;/sup&gt; that pops in your eyes is:

```
int FirstFactorial(int num);
cout &lt;&lt; FirstFactorial(gets(stdin));
```

So, ok, the code calls `gets` which is deprecated since C++11 and removed since C++14 which is bad in itself. 

But then I realize: `gets` is of type `char*(char*)`. So it shouldn&#39;t accept a `FILE*` parameter and the result shouldn&#39;t be usable in the place of an `int` parameter, but ... not only it compiles without any warnings or errors, but it runs and actually passes the correct input value to `FirstFactorial`.

Outside of this particular site, the code doesn&#39;t compile (as expected), so what is going on here?

---

&lt;sup&gt;*Actually the first one is `using namespace std` but that is irrelevant to my issue here.&lt;/sup&gt;

  [1]: https://www.coderbyte.com/editor/guest:First%20Factorial:Cpp



What is going on with &#39;gets(stdin)&#39; on the site coderbyte?

Consider the following inlined function :

    // Inline specifier version
    #include&lt;iostream&gt;
    #include&lt;cstdlib&gt;
    
    inline int f(const int x);
    
    inline int f(const int x)
    {
        return 2*x;
    }
    
    int main(int argc, char* argv[])
    {
        return f(std::atoi(argv[1]));
    }

and the constexpr equivalent version :

    // Constexpr specifier version
    #include&lt;iostream&gt;
    #include&lt;cstdlib&gt;
    
    constexpr int f(const int x);
    
    constexpr int f(const int x)
    {
        return 2*x;
    }
    
    int main(int argc, char* argv[])
    {
        return f(std::atoi(argv[1]));
    }

My question is : does the `constexpr` specifier imply the `inline` specifier in the sense that if a non-constant argument is passed to a `constexpr` function, the compiler will try to `inline` the function as if the `inline` specifier was put in its declaration ?

Does the C++11 standard guarantee that ?




Does constexpr imply inline?

The section $3.6.1/1 from the C++ Standard reads,

&gt; A program shall contain a global
&gt; function called **main**, which is the
&gt; designated **start** of the program.

Now consider this code,

    int square(int i) { return i*i; }
    int user_main()
    { 
        for ( int i = 0 ; i &lt; 10 ; ++i )
               std::cout &lt;&lt; square(i) &lt;&lt; endl;
        return 0;
    }
    int main_ret= user_main();
    int main() 
    {
            return main_ret;
    }

This sample code does what I intend it to do, i.e printing the square of integers from 0 to 9, **before** entering into the `main()` function which is supposed to be the &quot;start&quot; of the program.

I also compiled it with `-pedantic` option, GCC 4.5.0. It gives no error, not even warning!

So my question is, 

**Is this code really Standard conformant?**

If it&#39;s standard conformant, then does it not invalidate what the Standard says? `main()` is not start of this program! `user_main()` executed before the `main()`. 

I understand that to initialize the global variable `main_ret`, the `use_main()` executes first but that is a different thing altogether; the point is that, it **does** invalidate the quoted statement $3.6.1/1 from the Standard, as `main()` is NOT the *start* of the program; it is in fact the **end** of *this* program!

---

EDIT:

## How do you define the  word &#39;start&#39;?

It boils down to the definition of the phrase *&quot;start of the program&quot;*. So how exactly do you define it?


Is main() really start of a C++ program?

Consider the following code:

    #include &lt;iostream&gt;
    
    struct foo
    {
        // (a):
        void bar() { std::cout &lt;&lt; &quot;gman was here&quot; &lt;&lt; std::endl; }

        // (b):
        void baz() { x = 5; }
    
        int x;
    };
    
    int main()
    {
        foo* f = 0;
    
        f-&gt;bar(); // (a)
        f-&gt;baz(); // (b)
    }

We expect `(b)` to crash, because there is no corresponding member `x` for the null pointer. In practice, `(a)` doesn&#39;t crash because the `this` pointer is never used.

Because `(b)` dereferences the `this` pointer (`(*this).x = 5;`), and `this` is null, the program enters undefined behavior, as dereferencing null is always said to be undefined behavior.

Does `(a)` result in undefined behavior? What about if both functions (and `x`) are static?

When does invoking a member function on a null instance result in undefined behavior?

Is it possible to use a RegEx to validate, or sanitize Base64 data?  That&#39;s the simple question, but the factors that drive this question are what make it difficult.&lt;p&gt;

I have a Base64 decoder that can not fully rely on the input data to follow the RFC specs.  So, the issues I face are issues like perhaps Base64 data that may not be broken up into 78 (I think it&#39;s 78, I&#39;d have to double check the RFC, so don&#39;t ding me if the exact number is wrong) character lines, or that the lines may not end in CRLF; in that it may have only a CR, or LF, or maybe neither.

So, I&#39;ve had a hell of a time parsing Base64 data formatted as such.  Due to this, examples like the following become impossible to decode reliably.  I will only display partial MIME headers for brevity.

    Content-Transfer-Encoding: base64
    
    VGhpcyBpcyBzaW1wbGUgQVNDSUkgQmFzZTY0IGZvciBTdGFja092ZXJmbG93IGV4YW1wbGUu

Ok, so parsing that is no problem, and is exactly the result we would expect.    And in 99% of the cases, using any code to at least verify that each char in the buffer is a valid base64 char, works perfectly.  But, the next example throws a wrench into the mix.

    Content-Transfer-Encoding: base64
    
    http://www.stackoverflow.com
    VGhpcyBpcyBzaW1wbGUgQVNDSUkgQmFzZTY0IGZvciBTdGFja092ZXJmbG93IGV4YW1wbGUu

This a version of Base64 encoding that I have seen in some viruses and other things that attempt to take advantage of some mail readers desire to parse mime at all costs, versus ones that go strictly by the book, or rather RFC; if you will.
&lt;p&gt;
My Base64 decoder decodes the second example to the following data stream.  And keep in mind here, the original stream is all ASCII data!

    [0x]86DB69FFFC30C2CB5A724A2F7AB7E5A307289951A1A5CC81A5CC81CDA5B5C1B19481054D0D
    2524810985CD94D8D08199BDC8814DD1858DAD3DD995C999B1BDDC8195E1B585C1B194B8

Anyone have a good way to solve both problems at once?  I&#39;m not sure it&#39;s even possible, outside of doing two transforms on the data with different rules applied, and comparing the results.  However if you took that approach, which output do you trust?  It seems that ASCII heuristics is about the _best_ solution, but how much more code, execution time, and complexity would that add to something as complicated as a virus scanner, which this code is actually involved in?  How would you train the heuristics engine to learn what is acceptable Base64, and what isn&#39;t?

----------

**UPDATE:**
-----------

Do to the number of views this question continues to get, I&#39;ve decided to post the simple RegEx that I&#39;ve been using in a C# application for 3 years now, with hundreds of thousands of transactions.  Honestly, I like the answer given by [Gumbo][1] the best, which is why I picked it as the selected answer.  But to anyone using C#, and looking for a very quick way to at least detect whether a string, or byte[] contains valid Base64 data or not, I&#39;ve found the following to work very well for me.

    [^-A-Za-z0-9+/=]|=[^=]|={3,}$

And yes, this is just for a *STRING* of Base64 data, NOT a properly formatted [RFC1341][2] message.  So, if you are dealing with data of this type, please take that into account before attempting to use the above RegEx.  If you are dealing with Base16, Base32, Radix or even Base64 for other purposes (URLs, file names, XML Encoding, etc.), then it is _highly_ recommend that you read [RFC4648][3] that [Gumbo][4] mentioned in his answer as you need to be well aware of the charset and terminators used by the implementation before attempting to use the suggestions in this question/answer set.


  [1]: https://stackoverflow.com/users/53114/gumbo/ &quot;Gumbo&quot;
  [2]: https://www.rfc-editor.org/rfc/rfc1341 &quot;RFC1341&quot;
  [3]: https://www.rfc-editor.org/rfc/rfc4648 &quot;RFC4648&quot;
  [4]: https://stackoverflow.com/users/53114/gumbo/ &quot;Gumbo&quot;

RegEx to parse or validate Base64 data

A dot `.` in a regular expression matches any single character. In order for regex to match a dot, the dot has to be escaped: `\.`

[It has been pointed out to me](https://stackoverflow.com/questions/19967972/using-multiple-delimiters-for-split-in-java/19967996#comment29723775_19967996) that inside square brackets `[]` a dot does not have to be escaped. For example, the expression: 
`[.]{3}` would match `...` string.

Doesn&#39;t it, really? And if so, is it true for all regex standards?

Does a dot have to be escaped in a character class (square brackets) of a regular expression?

In a bash script, I need to launch the user web browser. There seems to be many ways of doing this:

* `$BROWSER`
* `xdg-open`
* `gnome-open` on GNOME
* `www-browser`
* `x-www-browser`
* ...

Is there a more-standard-than-the-others way to do this that would work on most platforms, or should I just go with something like this:

    #/usr/bin/env bash
    
    if [ -n $BROWSER ]; then
      $BROWSER &#39;http://wwww.google.com&#39;
    elif which xdg-open &gt; /dev/null; then
      xdg-open &#39;http://wwww.google.com&#39;
    elif which gnome-open &gt; /dev/null; then
      gnome-open &#39;http://wwww.google.com&#39;
    # elif bla bla bla...
    else
      echo &quot;Could not detect the web browser to use.&quot;
    fi



Clean way to launch the web browser from shell script?

&lt;pre&gt;Strict Standards: Declaration of childClass::customMethod() should be compatible with that of parentClass::customMethod()
&lt;/pre&gt;
What are possible causes of this error in PHP? Where can I find information about what it means to be *compatible*?

Declaration of Methods should be Compatible with Parent Methods in PHP

Surprise -- this is a perfectly valid query in MySQL:

    select X, Y from someTable group by X

If you tried this query in Oracle or SQL Server, you’d get the natural error message:

    Column &#39;Y&#39; is invalid in the select list because it is not contained in 
    either an aggregate function or the GROUP BY clause.

So how does MySQL determine which Y to show for each X?  It just picks one.  From what I can tell, it just picks the first Y it finds.  The rationale being, if Y is neither an aggregate function nor in the group by clause, then specifying “select Y” in your query makes no sense to begin with.  Therefore, I as the database engine will return whatever I want, and you’ll like it.

There’s even a MySQL configuration parameter to turn off this “looseness”.
http://dev.mysql.com/doc/refman/5.7/en/sql-mode.html#sqlmode_only_full_group_by

This article even mentions how MySQL has been criticized for being ANSI-SQL non-compliant in this regard.
http://www.oreillynet.com/databases/blog/2007/05/debunking_group_by_myths.html

My question is:  ***Why*** was MySQL designed this way?  What was their rationale for breaking with ANSI-SQL?


Why does MySQL allow &quot;group by&quot; queries WITHOUT aggregate functions?

Is it valid html to have the following:

    &lt;form action=&quot;a&quot;&gt;
        &lt;input.../&gt;
        &lt;form action=&quot;b&quot;&gt;
            &lt;input.../&gt;
            &lt;input.../&gt;
            &lt;input.../&gt;
        &lt;/form&gt;
        &lt;input.../&gt;
    &lt;/form&gt;

So when you submit &quot;b&quot; you only get the fields within the inner form. When you submit &quot;a&quot; you get all fields minus those within &quot;b&quot;.

If it isn&#39;t possible, what workarounds for this situation are available?


Is it valid to have a html form inside another html form?

I understand that an id must be unique within an HTML/XHTML page.

For a given element, can I assign multiple ids to it?

    &lt;div id=&quot;nested_element_123 task_123&quot;&gt;&lt;/div&gt;

I realize I have an easy solution with simply using a class. I&#39;m just curious about using ids in this manner.





All Standards Compliance Solutions on Gang of Coders

Total of 16 Standards Compliance Solutions

What is the "-->" operator in C/C++?