std::vector<int> someList;
int total = 0;
std::for_each(someList.begin(), someList.end(), <&>(x) {total += x});

Length operator"_miles"(float fValue) {return Length(fValue, Length::MILES);}
Length someLength = 12.5_miles // Вах!!!;

E>Length operator"_miles"(float fValue) {return Length(fValue, Length::MILES);}
E>Length someLength = 12.5_miles // Вах!!!;

Length operator"miles"(float fValue) {return Length(fValue, Length::MILES);}
Length someLength = 12.5 miles;

E>Length operator"_miles"(float fValue) {return Length(fValue, Length::MILES);}
E>Length someLength = 12.5_miles // Вах!!!;
E>

length_t miles(float v) { return length_t(v, length_t::MILES); }
length_t some_length = miles(12.5);

CS>length_t miles(float v) { return length_t(v, length_t::MILES); }
CS>length_t some_length = miles(12.5);
CS>

1u
2ll
3ull
4.0d

R>1u
R>2ll
R>3ull
R>4.0d
R>

length_t operator"mm"(float v) { return length_t(v, length_t::MM); }

active
{
  // First block.
  {
    // ...
  }
  // Second block.
  for( int j = N ; j > 0 ; j-- )
  {
    // ...
  }
  // Third block.
  ret = function(parameter) ;
  // Other blocks.
  // ...
}
All blocks are executed in parallel. After the execution of every block has ended, the program continues with a single thread.

int function( int parameter ) ;
// Calls the function and immediately returns.
IdThreadType<function> IdThread = future function(parameter) ;
// Waits for the function result.
int ret = wait IdThread ;

E>Скорей бы это все реализовали, а то ведь и слюной захлебнуться можно

struct CB {
    int f( int);
};

struct CD : CB {
    float f ( float );
    CB::f;
};

I>Length operator"miles"(float fValue) {return Length(fValue, Length::MILES);}
I>Length someLength = 12.5 miles;
I>

const double miles = ...;//
Length someLength = 12.5 * miles.

int main( )
{
  shared_ptr<double> p_first(new double) ;

  if( true )
  {
    shared_ptr<double> p_copy = p_first ;

    *p_copy = 21.2 ;

  }  // Destruction of 'p_copy' but not of the allocated double.

  return ;  // Destruction of 'p_first' and accordingly of the allocated double.
}

std::vector<int> someList;
std::remove_if(someList.begin(), someList.end(), <>(int x, int myTotal = 0){(myTotal += x) > 20};

CS>std::vector<int> someList;
CS>std::remove_if(someList.begin(), someList.end(), <>(int x, int myTotal = 0){(myTotal += x) > 20};
CS>

std::vector<int> someList;
std::remove_if(someList.begin(), someList.end(), lambda(int x):int myTotal = 0{ return (myTotal += x) > 20; });

typedef int(*Adder)(int);
Adder makeAdder(int y){ return lambda(int x){ return y + x; }}
add3 = makeAdder(3);
int r = add3(5);
//результат 8

lambda(x):myTotal = 0{ return (myTotal += x) > 20; }

template<class T, class F>
F makeAdder(T y){ return lambda(T x){ return y + x; }}
//и т.д.

CS>std::vector<int> someList;
CS>std::remove_if(someList.begin(), someList.end(), <>(int x, int myTotal = 0){(myTotal += x) > 20};
CS>

std::remove_if(someList.begin(), someList.end(), <>(int x: int myTotal = 0){(myTotal += x) > 20};

E>std::remove_if(someList.begin(), someList.end(), <>(int x: int myTotal = 0){(myTotal += x) > 20};
E>

<>(int x: int myTotal = 0)

CS><>(int x: int myTotal = 0)
CS>

import tango.io.Stdout;

void each(T)( T[] array, void delegate(T item) dg )
    {
        foreach( a; array )
            dg( a );
    }

void main()
    {
        int[] i = [ 1, 2, 3, 4 ];
        i.each( delegate void( int a ) {
            int x;
            Stdout.formatln( "x={0}, a={1}", x, a );
            x = a;
        } );
    }

x=0, a=1
x=0, a=2
x=0, a=3
x=0, a=4

    std::vector<std::string> v;
    struct
    {
        bool operator()(const std::string &s1, const std::string &s2)
        {
            return s1 > s2;
        }
    } pred;
    std::sort(v.begin(), v.end(), pred);// error C2919: illegal use of anonymous local type in template instantiation

    std::vector<std::string> v;
    sort(v.begin(), v.end(),
        struct{bool operator()(const std::string &s1, const std::string &s2)
        {
            return s1 > s2;
        }});

E>Хорошее, привычное поведение. Зачем бы его рушить?

double MyFun(),x=MyFun();

Myclass(x);

Allow 'sizeof' to work on members of classes without an explicit object
In standard C++, the sizeof operation can be used on types and objects. But it cannot be used to do the following:

struct SomeType { OtherType member; };

sizeof(SomeType::member); //Does not work.

#include <stdio.h>

struct B {
  int b[100];
};

struct A {
  B a;
};

#define MEMBER_SIZEOF(Class,Member) \
  sizeof(reinterpret_cast<Class*>(0x0)->Class::Member)

int main () {
  printf("%d\n",MEMBER_SIZEOF(A,a));

  return 0;
}

struct A {};
void f()
{ A* ptr;
  void *v;
   ..........
  ptr=(A*)v;
}

struct A {};
struct B:A { virtual void vf(){}};
void f()
{ B* ptr;
  void *v;
   ..........
  ptr=(A*)v;
}

function< void (int) >
make_closure( const char * file_name )
  {
    std::ofstream file( file_name );
    return <>(int x: &file){ file << i; }
  }

.>    std::vector<std::string> v;
.>    struct
.>    {
.>        bool operator()(const std::string &s1, const std::string &s2)
.>        {
.>            return s1 > s2;
.>        }
.>    } pred;
.>    std::sort(v.begin(), v.end(), pred);// error C2919: illegal use of anonymous local type in template instantiation
.>

struct Local
{
    static bool myCompare(std::string const& s1, std::string const& s2)
    {
        return s1.size() < s2.size();
    }
};

std::sort(v.begin(), v.end(), &Local::myCompare);

V>#define MEMBER_SIZEOF(Class,Member) \
V>  sizeof(reinterpret_cast<Class*>(0x0)->Class::Member)
V>

template <class X>
X& make();

#define MEMBER_SIZEOF1(cl, member) sizeof(make<cl>().member)

template <std::size_t N>
struct Size
{
    typedef char (&type)[N];
};

template <class C, class I>
typename Size<sizeof(I)>::type memberSizeofHelper(I C::*);

#define MEMBER_SIZEOF2(member) sizeof(memberSizeofHelper(&member))

// было
#pragma omp parallel for
for(int i = 0; i < n; ++i)
{
    dst[i] = f(src[i]);
}

// стало
for [[omp::parallel]] (int i = 0; i < n; ++i) // можно сделать макрос
{
    dst[i] = f(src[i]);
}

Bottom Line it For Me.

The monthly rent for our offices, when fully occupied, will run about $700 per employee. <…> I suspect that $700 per person is on the high side for software developers throughout the world, but if it means we can hire from the 99.9 percentile instead of the 99 percentile, it'll be worth it.