और भी आधुनिक सी ++

"सी ++ 11 एक नई भाषा की तरह लगता है।" - ब्रेज़न स्ट्रॉस्ट्रुप

कुछ समय पहले, हर्ब सटर ने अपनी वेबसाइट पर एक नया पेज खोला - एलिमेंट्स ऑफ़ मॉडर्न C ++ स्टाइल , जहाँ उन्होंने नए मानक के फायदों का वर्णन किया है और वे कोड को कैसे प्रभावित करेंगे।

C ++ 11 मानक कई नई विशेषताओं का परिचय देता है। इसके अलावा, हम उनमें से उन पर विचार करेंगे, जिनके कारण C ++ 11 को C ++ 98 की तुलना में एक नई भाषा माना जा सकता है, अर्थात्:

• वे नए मुहावरों को पेश करते हुए आपके कोड की शैली को बदलते हैं। वे C ++ पुस्तकालयों की वास्तुकला को प्रभावित करेंगे। उदाहरण के लिए: स्मार्ट पॉइंटर्स अधिक व्यापक हो जाएंगे (दोनों कार्यों के तर्क के रूप में और उनके रिटर्न मान), साथ ही ऐसे फ़ंक्शन जो मूल्य द्वारा बड़ी वस्तुओं को वापस करते हैं।
• उनका उपयोग इतनी बार और तीव्रता से किया जाएगा कि आप उनसे हर दूसरे कोड उदाहरण में मिलेंगे। उदाहरण के लिए: ऑटो कीवर्ड का उल्लेख किए बिना कोड की पांच या अधिक लाइनों का शायद ही कोई उदाहरण होगा।

C ++ 11 की अन्य विशेषताओं का उपयोग करने के लिए स्वतंत्र महसूस करें। लेकिन सबसे पहले, नीचे सूचीबद्ध लोगों पर ध्यान दें, क्योंकि यह उनके लिए धन्यवाद है कि C ++ 11 में स्वच्छ, सुरक्षित और तेज कोड लिखना संभव है - अन्य आधुनिक भाषाओं के मामले में जितना साफ और सुरक्षित है। खैर, हमेशा की तरह C ++ का पारंपरिक प्रदर्शन शीर्ष पर है।

ऑटो

जहाँ भी संभव हो, ऑटो कीवर्ड का उपयोग करें।
सबसे पहले, उस प्रकार के नाम को न दोहराएं जिसके बारे में हम और संकलक पहले से ही जानते हैं:

// C++98
map<int,string>::iterator i = m.begin();
 
// C++11
auto i = begin(m);

-, , , .

// C++98
binder2nd< greater<int> > x = bind2nd( greater<int>(), 42 );
 
// C++11
auto x = [](int i) { return i > 42; };

, auto . - , - . , .

- auto, , , . , — . auto: , ( , , , ).

: delete

. delete ( , ).

— shared_ptr, .

// C++98
widget* pw = new widget();
:::
delete pw;
 
// C++11
auto pw = make_shared<widget>();

(, ), weak_ptr.

// C++11
class gadget;
 
class widget {
private:
    shared_ptr<gadget> g;
};
 
class gadget {
private:
    weak_ptr<widget> w;
};

, , unique_ptr, . “new T” , . unique_ptr.

// C++11 Pimpl Idiom
class widget {
    :::
private:
    class impl;
    unique_ptr<impl> pimpl;
};
 
//  .cpp 
class impl {
    :::
};
 
widget::widget()
    : pimpl( new impl() )
{
}

, , .

// C++11
class node {
 vector< unique_ptr<node> > children;
 node* parent;
public:
 :::
};

nullptr

nullptr 0 NULL, , .

// C++98
int* p = 0;
 
// C++11
int* p = nullptr;

for range

for', range, .

// C++98
for( vector<double>::iterator i = v.begin(); i != v.end(); ++i ) {
    total += *i;
}
 
// C++11
for( auto d : v ) {
    total += d;
}

begin end

begin end , , , STL .begin() .end().

-STL , , .begin() .end(), begin end , , STL. , , C.

vector<int> v;
int a[100];
 
// C++98
sort( v.begin(), v.end() );
sort( &a[0], &a[0] + sizeof(a)/sizeof(a[0]) );
 
// C++11
sort( begin(v), end(v) );
sort( begin(a), end(a) );

. STL 100. - (PPL), (C++ AMP).

: v, x y.

// C++98:    ( std::find_if   )
vector<int>::iterator i = v.begin(); // i   
for( ; i != v.end(); ++i ) {
    if( *i > x && *i < y ) break;
}
 
// C++11:  std::find_if
auto i = find_if( begin(v), end(v), [=](int i) { return i > x && i < y; } );
</
source>

    - ,    ?   —      ,  ,       ,       ,     , ..      .
<source>// C#
lock( mut_x ) {
    ... use x ...
}

// C++11 without lambdas: already nice, and more flexible (e.g., can use timeouts, other options)
{
    lock_guard<mutex> hold { mut_x };
    ... use x ...
}

// C++11 with lambdas, and a helper algorithm: C# syntax in C++
// Algorithm: template<typename T> void lock( T& t, F f ) { lock_guard hold(t); f(); }
lock( mut_x, [&]{
    ... use x ...
});

. . Lambdas, Lambdas Everywhere PDC 2010.

Move / &&

API. .

// C++98:   
vector<int>* make_big_vector(); //  1:  :  ,     delete
:::
vector<int>* result = make_big_vector();
void make_big_vector( vector<int>& out ); //  2:   :  ,     
:::
vector<int> result;
make_big_vector( result );
 
// C++11: 
vector<int> make_big_vector();
:::
vector<int> result = make_big_vector();

- , , .

: , POD auto, { } .

// C++98 or C++11
int a = 42;        //  , 

// C++ 11
auto x = begin(v); //   

, ( ) , . : ( float int), POD . C++98: , -

// C++98
rectangle       w( origin(), extents() );   // oops, declares a function, if origin and extents are types
complex<double> c( 2.71828, 3.14159 );
int             a[] = { 1, 2, 3, 4 };
vector<int>     v;
for( int i = 1; i <= 4; ++i ) v.push_back(i);

// C++11
rectangle       w = { origin(), extent() }; // = is optional but I personally prefer it
complex<double> c = { 2.71828, 3.14159 };   // = is optional but I personally prefer it
int             a[] = { 1, 2, 3, 4 };
vector<int>     v = { 1, 2, 3, 4 };

{ } :

// C++98
X::X( /*...*/ ) : mem1(init1), mem2(init2, init3) { /*...*/ }

// C++11
X::X( /*...*/ ) : mem1{init1}, mem2{init2, init3} { /*...*/ }

, :
void draw_rect( rectangle );

// C++98
draw_rect( rectangle( myobj.origin, selection.extents ) );

// C++11
draw_rect( { myobj.origin, selection.extents } );

C++ . . .

, — must-know. C++, . C++ . C++ , — , .