Auxiliary variables are useful for giving per instance scoped variables to the lambda and it's also the only way to move data inside the lambda. i.e. something like (notice the semi-colons):

string str = "asdfasdfasdfasdfasdfasdf";
string s2;

[&; auto s = move(str); const size_t n = s.length()*4] {
s2 += s;
s2.resize(n, '!');
}();

cout << str << endl << s2 << endl;

This example gets treated as if you wrote:

struct gensym {
string &s2;
mutable string s;
const size_t n;

bleh(string &s2, const string &str) :
s2(s2), s(move(str)), n(s.length()*4)
{}

void operator() const
{
s2 += s;
s2.resize(n, '!');
}
};

string str = "asdfasdfasdfasdfasdfasdf";
string s2;

gensym(s2, str)();

cout << str << endl << s2 << endl;

The D language provides scope guard statements (http://dlang.org/statement.html#ScopeGuardStatement), which is a language-level implementation of C++'s RAII concept. It allows arbitrary code to run when the scope exits, either in normal code flow, exceptional code flow, or unconditionally. This has proved to be extremely useful in managing resources and transactions.

In C++ this can be emulated somewhat simply (especially in C++11), but C has no mechanics to emulate it at all. The only extension that gets close is __finally, but this is largely unmaintainable in practice and less effective in improving clarity, distancing initialization from destruction. Adding this new extension would allow C programmers to take advantage of scope-bound resource management without requiring them to translate all their code to C++ (important for legacy code bases), and ultimately opens the door to adding scope guards as a language feature in C or C++.

The extension is very simple to implement yet adds extraordinary power, and could take on the following syntax (requiring only one new keyword and three context-sensitive keywords):

__scope(exit) free_some_resource(r);
__scope(failure) undo_some_transaction(t);
__scope(success) { log_success(here); log_success(there) ; }

Alternatively, one could simply introduce three new keywords: __scope_exit, etc.

Consider how this canonical C code becomes simplified. Before:

int main(void)
{
int retVal = 0;

char *mem = malloc(4);
if (!mem)
{
retVal = -1;
goto cleanup_none;
}

if (prepare_mem(mem) != 0)
{
retVal = -1;
goto cleanup_malloc;
}

FILE *f = fopen("test", "w");
if (!f)
{
retVal = -1;
goto cleanup_malloc;
}

if (prepare_file(f) != 0)
{
retVal = -1;
goto cleanup_file;
}

/* Use memory and file, etc. */

cleanup_file:
fclose(fp);
cleanup_malloc:
free(mem);
cleanup_none:
return retVal;
}

After:

int main(void)
{
char *mem = malloc(4);
if (!mem)
return -1;

__scope(exit) free(mem);

if (prepare_mem(mem) != 0)
return -1;

FILE *f = fopen("test", "w");
if (!f)
return -1;

__scope(exit) fclose(fp);

if (prepare_file(f) != 0)
return -1;

/* Use memory and file, etc. */

return 0;
}

Additionally, it will also work with SEH exceptions, without huge nestings of __finally clauses.

Hi guys

I wana discuss proposed optimization step(optional switch?) to c++ compiller that would make old and new code in some cases order of magnitude faster by just pure recompilation. Since visual c++ compiller is closed source I am testing changes in CLang

...After all those attempts to store anything via = without waste I think that compiller should do "placement new" transparently for us whenever he encounters = on movable object(just array case is more than enough). Instead of forcing us to implement zillion && operators that solve only heap side of problem. Deciding what kind of "this" object should use is easy since static analysis deciding what object is movable is already part of new compillers as part of support for &&.

Skyscrapper city[1000]; // instead of temp
city[1] = Skyscrapper("Empire State Building"); // compiller should use &city[1] as this pointer

This would fix heap and static waste = zero alloc/copy.
Why is static mem waste equally if not more important? Majority of objects are small thus majority of their memory is static.

Benchmark results in article www codeproject com/Articles/453022/The-new-Cplusplus-11-rvalue-reference-and-why-you#fix

Regards Ladislav [Unemployed]
neuralll[@]gmail[.]com

There must be support for converting a complete project developed in “C” language to “C++” or “C#”.
It should not be simple file name replacement but should have below:

1) All the “struct” definition would be moved to “class” definition.
2) New classes introduced for each “.C” code file, based on the user input.
3) All the global or static function would become methods of the classes ot might remain as it is based on the user choice.
4) Need to handle use of “function pointer” and moved to inheritance hierarchy. ***** very complicated.
I can suggest design for the same

Best Regards,
Ritesh Vaswani

Why?
Compiler generating non identical code for inline (Is that bug?). For example:

inline bool iszero(int a)
{
return (a == 0);
}

int main()
{
int a = 4;

if(a == 0) // First
a = 5;

if(iszero(a)) // Second
a = 5;

///...
}
In debug mode (with inlining) disasembled code look like:

if(a == 0) // First
a = 5;

bool temp; // Second
if(a == 0)
temp = 0;
else
temp = 1;

if(temp == 0)
a = 5;

Unwanted code... Macros perfectly work and do not generate unwanted code! But macros can not get access to private members of class.