R *pr1=new R;
R *pr2=new(R);

R *pr1=new R;
А>R *pr2=new(R);
А>

[Note: parentheses in a new-type-id of a new-expression can have surprising effects. [Example:

new int(*[10])(); // error

is ill-formed because the binding is

(new int) (*[10])(); // error

Instead, the explicitly parenthesized version of the new operator can be used to create objects of compound types (3.9.2):

new (int (*[10])());

allocates an array of 10 pointers to functions (taking no argument and returning int). ] ]

5.3.4/12

[Example:
— new T results in a call of operator new(sizeof(T)),
— new(2,f) T results in a call of operator new(sizeof(T),2,f),
— new T[5] results in a call of operator new[](sizeof(T)*5+x), and
— new(2,f) T[5] results in a call of operator new[](sizeof(T)*5+y,2,f).

...............................................
...............................................
int *get_ptr(){
    int i = 4444;
    return &i;
}
...............................................
...............................................
    Tmp *pt4 = new(&Tmp())Tmp;
    Tmp *pt5 = 0;
    {
        Tmp tmp = {55555};
        pt5 = new(&tmp)Tmp;
    }
    int *x6 = 0;
    {
        int local_x = 88888;
        x6 = &local_x;
    }
    int *x7 = get_ptr();
    cout << "[" << pt4->x << " " << pt5->x << " "  << *x6 << " "  << *x7 << "]" << endl;
...............................................
...............................................

std::size_t a = sizeof(int); // ok
std::size_t b = sizeof int;  // error
std::size_t c = sizeof(a);   // ok
std::size_t d = sizeof a;    // ok

new< int(*[10])() >
new< int(*[10])() >(initializer)
new<Type>(args)

// сравните с

factory_func<Type>(args)
static_cast<Type>(obj)

void * operator new(size_t s, int i){
    char *str[sizeof(Boo)];
    Boo *bbb=reinterpret_cast<Boo*>(str);
    return bbb;

}; 
void * operator new(size_t s){
    Boo *bbb=(Boo*)malloc(s);
    return bbb;

};

class Tmp{
public:
    int x;
};

Кё>new< int(*[10])() >
Кё>new< int(*[10])() >(initializer)
Кё>new<Type>(args)

Кё>// сравните с

Кё>factory_func<Type>(args)
Кё>static_cast<Type>(obj)
Кё>

template <class X, class... Args>
std::unique_ptr<X> newest(Args...&& args)
{
    return std::unique_ptr<X>(new X(args...));
}

newest<int>(0);
newest<std::vector<std::string>>(42, "hello");

int *get_ptr()
{
    int i = 4444;
    return &i;
}

class Tmp{
public:
    int x;
};

#include <iostream>

int main()
{
    Tmp *pt4 = new(&Tmp())Tmp;
    Tmp *pt5 = 0;
    {
        Tmp tmp = {55555};
        pt5 = new(&tmp)Tmp;
    }
    int *x6 = 0;
    {
        int local_x = 88888;
        x6 = &local_x;
    }
    int *x7 = get_ptr();
    std::cout << "[" << pt4->x << " " << pt5->x << " "  << *x6 << " "  << *x7 << "]" << std::endl;

}

"ComeauTest.c", line 4: warning: returning pointer to local variable
return &i;
^

"ComeauTest.c", line 16: error: expression must be an lvalue or a function
designator
Tmp *pt4 = new(&Tmp())Tmp;

A>Брр... Жуткое использование адреса локальных переменных вне области их действия. Быстренько учим матчасть!

Я предполагал, что выводиться должен мусор, а получаю нормальные значения.
Это такая фича/бага VC++ или частый случай неопределённого поведения?

 Tmp *pt4 = new(&Tmp())Tmp;

 warning C4238: nonstandard extension used : class rvalue used as lvalue

warning C4172: returning address of local variable or temporary

# g++ -Wall test.cpp

g++ (GCC) 4.1.2 (Gentoo 4.1.2 p1.1)
Copyright (C) 2006 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

test.cpp: In function 'int* get_ptr()':
test.cpp:3: warning: address of local variable 'i' returned
test.cpp: In function 'int main()':
test.cpp:16: warning: taking address of temporary

A>std::size_t a = sizeof(int); // ok
A>std::size_t b = sizeof int;  // error
A>std::size_t c = sizeof(a);   // ok
A>std::size_t d = sizeof a;    // ok
A>

typedef int int_type;
...
sizeof int_type; // ok