Thread: C++0x

How do you get lamdas/etc to compile under the latest TDM in Code::Blocks?

Code:

#include <string>

int main()
{
    auto s = []()
    {
        std::string("hello world");
    };
}

In function 'int main()':
error: expected primary-expression before '[' token
error: expected primary-expression before ']' token
error: unable to deduce 'auto' from '<expression error>'
error: expected ',' or ';' before '{' token
=== Build finished: 4 errors, 0 warnings ===

I tried compiler settings -std=gnu++0x and -std=c++0x. That's what Google said. Neither worked. Thanks :]

GCC doesn't support lambdas yet.

lol Sebastiani, it's not an array, it's the new lambda syntax.

Originally Posted by CornedBee

GCC doesn't support lambdas yet.

Edit: Oops, it's just intel / gcc 4.4.1 - http://software.intel.com/en-us/blog...-lambdas-in-c/

Oh well, thanks.

Originally Posted by Sebastiani

I'm not sure if this is 100% C++0x compliant, but it looks promising.

That would be the "latest TDM" I mentioned in the OP. It looks good for sure, it's even up to date, unfortunately as CornedBee said GCC (I think he meant to specify GNU GCC) doesn't support lambda's yet.. Forgot about the progress page:

C++0x Support in GCC - GNU Project - Free Software Foundation (FSF)

Anyway, I keep reading suspicions of bloated filesizes, cpu usage, seg faults, and lack of popular library support for c++0x. It still looks decent, but I'll wait. I wonder if switching for just the auto keyword would cause any problems or be a bad choice :P

Anyway, I keep reading suspicions of bloated filesizes, cpu usage, seg faults, and lack of popular library support for c++0x.

Sounds completely nonsensical. Sure, you might get compiler segfaults in the experimental parts, but other than that ...

Originally Posted by CornedBee

Sounds completely nonsensical. Sure, you might get compiler segfaults in the experimental parts, but other than that ...

Nonsensical or not, that's just what I've read on mailing lists. How much of it is actually complete? Look at the list. At quarter of what's actually completed looks experimental. You've got to figure writing any decent sized script you're going to run into it sooner or later. The question is how long you'll be waiting for a bugfix, or converting all your code to use an older method. So you think it's worth switching? Disregarding tr1, just renamed boost.

The C++0x standard isn't finalized, so there's nothing wrong with these features being experimental. I wouldn't use them in production code yet, but mostly because I worry about cross-compiler portability.
However, the way compilers work, it's very unlikely that any of the C++0x features, except perhaps the multithreading stuff - leads to real miscompilations, where the resulting program crashes at runtime or is extremely slow.
The library features are a different matter. They are, like any new code, subject to bugs.

Some features are set in stone and is finalized, though. Lambdas and auto would be two of them. Otherwise compiler vendors wouldn't have attempted to implement any of it for a release.