The Next C++ Books you have to read !

C++ dalam tahun terakhir ini mengalami perkembangan yang sangat pesat. Banyak buku-buku atau artikel yang sudah tidak valid lagi. Kita sebaiknya membaca buku-buku yang terbaru mengenai c++ sehingga tidak menggunakan ilmu yang sudah lawas dan ketinggalan jaman. Berikut adalah beberapa buku yang sebaiknya dibaca untuk memperbaharui kemampuan c++ anda atau mungkin anda baru mulai belajar c++. Find this book and read it

 

1. C++ Primer Plus 

   Buku ini merupakan pengantar yang sangat bagus untuk c++ untuk level pemula. Mudah untuk diikuti dan lengkap. Buku ini sudah mencaai edisi ke enam sehingga sudah dapat dipastikan banyak peminatnya. Buku ini sudah mencakup c++ 11.

2. C++ in One Hour a Day 

   Pembagian waktu belajar dari buku ini cukup baik. Banyak hal-hal praktis yang disampaikan dari buku tersebut. Buku ini ditulis oleh MVP c++ sehingga anda dapat melihat penjelasan practical dan good programming practices di dalamnya

3. C++ Primer

   Telah di update untuk c++11. Membantu anda untuk mempelajari bahasa dengan cepat, menggunakannya secara modern dan cara yang efektif. Buku ini juga dipenuhi dengan best practices dan cara menggunakan core language dan standard library.

4. C++ Succinctly – C++ for C# Developers

   Buku ini ditulis untuk membantu developer c# mempelajari modern c++. Sehingga developer c# tidak perlu belajar dari ground zero, tetapi memanfaatkan pengetahuannya sebelumnya sehingga dapat menguasai bahasa ini dengan cepat.

5. The C++ Programming Language

   Buku ini ditulis oleh pencipta c++ dan berfungsi sebagai buku referensi lengkap dan bukan tutorial mengenai fitur bahasa. Buku ini akan segera terbit dan terupdate dengan fitur c++ 11.

6. The C++ Standard Library

   Buku ini memberikan pemahaman yang dalam tentang setiap komponen library dan penjelasan tentang design dari library. Dilengkapi juga dengan praktik programming yang effective dan kesalahan yang sering juga best practice. Banyak sample code yang dapat anda lihat pada buku ini.

7. C++ AMP

   Buku ini sangat practical buat c++ developer dalam mempelajari dasar parallel programming dengan c++ AMP. Kita dapat memanfaatkakn kekuatan GPU dengan C++ AMP sehingga aplikasi kita dapat memiliki performance yang lebih. Buku ini memiliki contoh yang detail dan case study.

8. Beginning Visual C++ 2012
   Buku ini mencakup pembahasan detail menggunakan c++ pada Visual Studio yang terbaru yaitu 2012. Anda dapat menemukan penjelasan dari c++ 11, c++/CLI, c++/CX dan penggunaan debugger dan tools lain nya pada visual studio.
9. Programming Windows 8 Apps with Microsoft Visual C++

   Anda dapat menggunakan skill visual c++ anda untuk membangun aplikasi modern dengan Windows 8. Buku ini akan menjelaskan secara rinci Windows Runtime dan c++/cx. Bagaimana anda dapat menggunakan native c++ pada windows store dan juga xaml untuk membuat modern ui. Buku ini akan segera terbit.

10. Building Windows 8 Apps with Microsoft Visual C++

    Buku ini seperti biasa akan memberikan detail step by step yang dapat anda ikuti. Secara lambat tapi pasti menjelaskan konsep disertai dengan praktek yang detail. Learn by doing exercises. Buku ini akan segera terbit.

Masih ada buku baru yg belum di daftarkan ? Let me know and i will update the list. Send me email at if05041 [at] gmail [dot] com

Advertisement

C++ Today – Let’s create C++ User Group Indonesia

Background

Hai rekan developer,

Mungkin banyak orang yang sudah meragukan apakah c++ masih relevan untuk dipelajari di jaman sekarang ini. Apalagi dengan kemunculan berbagai macam bahasa-bahasa yang menyediakan banyak syntatic sugar, managed code, automatic memory management anda segala kemudahan yang menggiurkan lainnya. C++ seperti padam dan tidak terdengar dengungnya dan semakin sepi kelihatannya penggemarnya di Indonesia. Banyak yang sudah langsung mempelajari Java, C# dan php sebagai bahasa pemrograman pertamanya. Hal ini tentu saja tidak salah, tetapi tanggapan bahwa c++ tidak relevan lagi di dunia industry untuk saat ini benar-benar merupakan kesalahan yang besar.

Apa yang menyebabkan banyak orang beranggapan demikian ?

Salah satunya mungkin adalah kesan yang buruk yang dialaemi oleh para programmer tersebut ketika belajar c++ pada jamannya. Sehingga tanggapan tersebut melekat dan kemudian disampaikan kepada orang-orang dan tidak ada orang yang mau membantah tanggapan tersebut. Tidak ada orang yang memberikan kabar baik mengenai c++ tersebut. Sehingga tidak ada lagi generasi yang membuat c++ sebagai first language of choicenya.

Dari hal diatas kita bisa lihat bahwa symptom nya adalah kita tidak memiliki komunitas yang kuat untuk menyebarkan keindahan c++ tersebut. What’s the matter with c++ community in Indonesia ? Kita telah melihat bahwa .NET dan Java memiliki komunitas yang saling berbagi mengenai perkembangan, mengadakan meeting, eksplorasi dsb.

Apakah memang sudah tidak ada lagi developer c++ yang ada di indonesia ? Apakah tidak ada lagi hal yang bisa dibagikan dari c++ ? Apakah sudah tidak ada lagi berita baru dan latest news dari c++ ? Saya sangat meragukan hal tersebut.

Saya menemukan beberapa artikel menarik yang mungkin dapat menggambarkan apa yang terjadi dengan komunitas c++. Hal ini tidak hanya terjadi di Indonesia tetapi juga di luar negeri. C++ developer dikategorikan sebagai Dark Matter developers. Mengapa disebut demikian ?

Karena meskipun c++ developer masih tetap exist dan saya yakin banyak jumlahnya. Tetapi mereka seolah-olah tidak terlihat. Mereka tidak pernah memunculkan dirinya di depan umum, tidak membaca atau menulis blog, tidak mengikuti atau membuat user group, no tweet, facebook etc etc. Tidak ada yang mengetahui bahwa mereka tetap membuat software dengan C++. Embedded developer tetap melakukan pekerjaannya dengan c dan c++ sementara banyak developer lain berlomba-lomba untuk mengejar the Next Big Thing dan cutting edge technology. Tetapi hey… Dark Matter Developers menghasilkan software !!

Dark Matter Developers: The Unseen 99%

Dark Matter Developers

Mungkin ini saatnya bahwa C++ developer berkumpul bersama, berbagi, menghapus semua tanggapan orang yang buruk mengenai c++. Let’s start, Stand Up and Speak Up. Banyak hal-hal baru yang perlu kita suarakan ke public. Banyak hal-hal lama juga yang mungkin tidak semua orang mengetahuinya perlu kita bagikan.

Modern C++ / C++ 11

Perkembangan C++ belakangan ini sangat pesat. Saya mungkin hanya mengamati di dunia windows, tetapi hal tersebut juga bakal terjadi di tempat lain yang tidak saya perhatikan. Beberapa diantaranya adalah C++11 telah membuat C++ seperti bahasa baru. Banyak hal-hal yang merupakan mimpi buruk bagi developer yang telah berubah. Lambda expression, auto, foreach etc etc.

Elements of Modern C++ Style

C++ semakin dibutuhkan lagi sekarang terutama untuk performance. C++ is fast. Tidak ada yang bisa membantah hal tersebut. Ketika kita menulis program. There’s nothing faster than native code. Run directly in the metal. Memanfaatkan semua kemampuan hardware secara optimize. Terlebih lagi di dunia parallel, multicore, cloud bla bla bla. C++ semakin dibutuhkan untuk memunculkan kemampuan tersembunyi yang ada di hardware tersebut ke software kita.

Dunia smartphone, tablet, device memiliki daya yang terbatas sehingga C++ merupakan salah satu pilihan yang tepat untuk memenuhi kebutuhan tersebut. C++ dapat memberikan sesuatu yang lebih dengan daya yang minimal.

Server Farm membutuhkan bahasa yang efficient sehingga power consumption bisa di reduce. Tidak banyak orang yang tahu mengenai hal tersebut. C++ developer knows that better than others. C++ memungkinkan kita membuat code yang efficient dengan tidak mengorbankan abstraksi. object oriented right ?

Windows 8

Windows 8 dan MetroStyle Apps, ya.. sekarang statusnya masih Consumer Preview or Beta. Tetapi dari yang saya amati, C++ is still the best in that world. Kita dapat memanfaatkan existing code dan menggunakannya untuk berhubungan dengan WinRT. Karena sebenarnya WinRT pada dasarnya adalah COM. Dan COM adalah C++. WinRT is Native. Seperti yang saya sebutkan di atas tidak ada yang bisa mengalahkan kecepatan dari native code. Dengan menggunakan C++ kita dapat memanfaatkan library Win32, membungkusnya didalam WinRT component sehingga dapat diakses dari bahasa lain seperti C# dan Javascript yang tidak memiliki kemampuan seperti itu. We should help each other right ?

Pada Windows 8 juga, hanya C++ yang bisa mengakses DirectX secara langsung. Jika kita ingin membuat games high performance MetroStyle apps kita sudah hampir pasti menggunakan C++. Nasib dari XNA masih belum jelas. SharpDx yang dapat digunakan oleh C# juga merupakan wrapper terhadap DirectX dan akan memberikan performance penalty dalam hal ini. So you should go with C++ in this case.

Visual Studio 2011 Beta

Banyak penambahan yang memberikan kemudahan kepada c++ developer dalam membangun aplikasi dengan Visual Studio. Versi 2011 beta ini menambahkan banyak lagi untuk para developer c++. Let’s get started with this page

What’s New in Visual Studio 11 Beta for C++ Developers    

Auto Vectorization

Compiler selalu di improve setiap release dan kita tidak menyadari bahwa code kita selalu di optimize. It’s just works. Visual Studio 2011 telah menambahkan fitur yang membuat code anda performace tanpa sepengetahuan kita. Code perulangan(loop) kita yang memiliki potensi untuk dijalankan parallel akan secara otomatis diubah sedemikian rupa sehingga dapat loop tersebut dapat dijalankan secara bersamaan. Loop menjadi lebih cepat pada CPU yang memiliki support terhadap SIMD instruction. Keuntungan ini hanya didapat oleh Native developer. Managed developer masih belum mendapatkan keuntungan yang serupa. 🙂

Auto-Vectorizer in Visual Studio 11 – Overview

GPGPU – C++ AMP

Masih di dunia parallelism, C++ AMP memberikan akelerasi code dengan memanfaatkan GPU yang biasanya digunakan untuk graphic menjalankan code kita lebih cepat. Kita dapat memindahkan high computation atau number crunching code dari CPU ke GPU. Hal ini belum dapat dilakukan oleh managed language seperti c#.

Overview of C++ Accelerated Massive Parallelism (C++ AMP)

How to use C++ AMP from C#

How to use C++ AMP from C# using WinRT

How to use C++ AMP from C++ CLR app

C++ User Group Indonesia

Begitu banyak hal yang bisa kita bagikan dan menunjukkan C++ tetap menjadi hal yang sangat layak untuk diperhitungkan sebagai first class language. Why not start from now ?

Let’s gather, let’s have a meeting, let’s have a discussion. Let’s create something great for our community.

Dengan demikian kita akan melahirkan lebih banyak lagi C++ developer di Indonesia, membangkitkan gairah belajar mahasiswa di universitas untuk membuat c++ sebagai bahasa favouritenya. And maybe someday they will end up in the big company that heavily invest in C++ like Microsoft, Google and Facebook. Who knows ?

🙂

Cheers

C++ AMP Resources

C++ selalu identik dengan kata-kata fast and performace.

C++ AMP merupakan salah satu hal yang menambahkan lebih banyak lagi persenjataan developer untuk mengejar masalah performance.

Berikut saya berikan beberapa article yang menjelaskan mengenai C++ AMP

C++ AMP delivers performance, in a hardware-portable manner, without compromising the productivity you’ve come to expect from modern C++ and the Visual Studio package. It could provide orders of magnitude speed gains compared with just using the CPU only. At conferences I typically demo a single process taking advantage of both NVIDIA and AMD GPUs at the same time, while still having a CPU fallback solution.

A Code based Introduction to C++ AMP

C++ AMP in a Nutshell

C++ AMP Sample

Screencasts on C++ AMP

Selamat melakukan ekplorasi menuju dunia parallel with GPU.

Cheers.

Elements of Modern C++ Style

Sumber : http://herbsutter.com/elements-of-modern-c-style/

Artikel berikut diambil dari blog Herb Sutter yang menjelaskan mengenai hal-hal yang perlu kita ketahui bersama dalam menulis code c++ dengan cara yang baru seiring dengan disahkannya standar c++11 oleh komite ISO C++.

Ada perubahan yang minor dilakukan oleh penerjemah dalam artikel ini dalam hal penyampaian. Saya berusaha agar perubahan tersebut tidak mengubah arti dari keseluruhan artikel tersebut.

C++11 seperti bahasa baru – Bjarne Stroustrup

Standar c++11 menawarkan banyak fitur baru yang bermanfaat. Artikel ini menitik beratkan secara spesifik untuk fitur baru yang membuat c++ menjadi bahasa baru dibandingkan dengan c++98, karena

• Standard ini mengubah gaya dan idiom yang kita gunakan dalam menulis kode C++, termasuk cara merancang library c++. Kita akan melihat banyak pengunaan parameter smart pointer, return value dan fungsi yang mengembalikan object besar dengan value.
• Standard akan digunakan menyebar sehingga anda akan melihatkan hampir disetiap contoh kode. Salah satunya, hampir setiap code program akan dimulai dengan keyword auto pada deklarasinya

Fitur yang lain dari c++11 tentu saja sangat bagus. Tetapi diharapkan anda terbiasa dengan hal-hal yang dikemukakan disini pertama kali, karena hal-hal berikut merupakan yang lazim digunakan untuk menunjukan mengapa kode c++11 bersih, aman dan cepat – sepadan dengan code yang ditulis dengan bahasa pemroraman mainstraim lain. Ditambahkan lagi kemampuan c++ yang dapat langsung mengakses hardware, performance yang tidak dimiliki bahasa modern lain, membuatnya lebih kuat dari semula.

Catatan:

• Seperti Strunk & White, halaman ini berfokus pada panduan dan kesimpulan singkat. Tidak ditujukan untuk menjadi sumber utama dari analisa kekurangan dan kelebihan dan hal yang detil. Hal tersebut akan dibahas pada artikel lain
• Dokumen ini adalah dokumen yang hidup. Sehingga akan terus menerus diperbaharui dan di revisi.

auto

Gunakan auto jika memungkinkan. Ada dua alasan utama. Pertama, kita tidak perlu repot lagi mengulangi nama tipe yang sudah kita tentukan dan diketahui oleh compiler.

// C++98
map<int,string>::iterator i = m.begin();
double const xlimit = config["xlimit"];
singleton& s = singleton::instance();

// C++11
auto i = begin(m);
auto const xlimit = config["xlimit"];
auto& s = singleton::instance();

Kedua, lebih nyaman lagi jika kita tidak mengetahui tipenya atau sulit dituliskan, seperti tipe dari fungsi lambda pada umumnya, dimana kita tidak dapat menuliskannya dengan mudah.

// C++98
binder2nd< greater > x = bind2nd( greater(), 42 );

// C++11
auto x = [](int i) { return i > 42; };

Perhatikan bahwa dengan menggunakan auto, makna dari kode tersebut tidak berubah. Code tersebut tetap statically typed dan tidak berubah menjadi dynamic typed. Dan tipe dari setiap ekpresi menjadi jelas, c++ tidak lagi memaksa kita untuk menuliskan nama tipe berulang ulang.

Beberapa orang pada mulanya takut untuk menggunakan auto, karena merasa ada kemungkinan bahwa tipe yang dikembalikan berbeda dari yang diharapkan. Jika anda ingin secara eksplisit memaksa konversi dari tipe, tidak masalah, anda bisa menyebutkan tipe targetnya. Tetapi untuk bagian yang lain diharapkan anda menggunakan auto saja. Cukup jarang ada situasi kita mendapatkan kesalahan tipe yang berbeda. Dan masih tetap strong static typing maka compiler akan mengingatkan anda jika anda karena kita berusaha memanggil fungsi atau variable yang tidak dimiliki oleh tipe tersebut.

Smart pointer : No Delete

Selalu gunakan smart pointers, dan non-owning raw pointers. Jangan gunakan owning raws pointers dan delete, kecuali di kasus langka dimana anda harus mengimplementasikan struktur data sendiri( meskipun demikian anda harus tetap menjaganya terenkapsulasi dalam batasan kelas)

Jika anda mengetahui bahwa anda hanyalah satu-satunya pemiliki dari object lain, maka gunakan unique_ptr untuk menujukkan kepemilikan tunggal.

Ekspresi “new T” seharusnya langsung menginisialisasi object lain yang memilikinya. Contoh klasiknya adalah Pimpl Idiom (see GotW #100):

// C++11 Pimpl idiom: header file
class widget {
public:
    widget();
    // ... (see GotW #100) ...
private:
    class impl;
    unique_ptr<impl> pimpl;
};

// implementation file
class widget::impl { /*...*/ };

widget::widget() : pimpl{ new impl{ /*...*/ } } { }
// ...

Gunakan shared_ptr untuk mengekspresikan kepemilikian bersama. Gunakan make_shared untuk menciptakan object yang di share tersebut dengan efisien.

// C++98
widget* pw = new widget();
:::
delete pw;

// C++11
auto pw = make_shared<widget>();

Gunakan weak_ptr untuk menghindari cycle dan mengekspresikan optionality (implementasi cache object)

// C++11
class gadget;

class widget {
private:
    shared_ptr<gadget> g; // if shared ownership
};

class gadget {
private:
    weak_ptr<widget> w;
};

Jika anda mengetahui bahwa object tersebut akan meninggalkan anda dan anda ingin mengamatinya, gunakan non-owning raw pointer.

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

Range for

Perulangan for each lebih nyaman digunakan untuk melakukan iterasi dari setiap elemen pada koleksi secara berurutan.

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

// C++11
for( auto d : v ) {
    total += d;
}

Non member begin dan end

Selalu gunakan nonmember begin(x) dan end(ex) (bukan x.begin() dan x.end()), karena begin(x) dan end(x) lebih ekstensible dan dapat digunakan dengan berbagai jenis tipe container bahkan array dan tidak hanya STL container yang menyediakan method x.begin() dan x.end()

Jika anda menggunakan collection non-STL yang menyediakan iterasi tetapi tidak memiliki x.begin() and x.end() anda dapat menuliskan versi overloading dari non-member begin(x) dan end(x) utuk tipe tersebut dimana anda dapat menjalani tipe koleksi tersebut dengan menggunakan gaya pemrograman yang sama dengan container STL. Standar memiliki beberapa contoh dari penggunaan untuk array 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) );

Fungsi Lambda dan Algoritma

Lambda merupakan perubahan yang sangat besar dan akan mengubah cara anda menulis kode menjadi lebih elegan dan cepat. Lambda membuat algoritma STL yang sudah ada menjadi lebih berguna 100 x lipat. Library c++ yang baru dirancang dengan mengunakan lambda (contoh: PPL (parallel pattern library)) dan beberapa diantaranya mewajibkan anda menggunakan lambda untuk menggunakan library tersebut (C++ AMP)

Berikut contoh singkatnya : Temukan elemen pertam di v dimana >x dan <y. Pada c++11, code yang paling simple dan bersih adalah dengan menggunakan algoritma standar yang tersedia

// C++98: write a naked loop (using std::find_if is impractically difficult)
vector<int>::iterator i = v.begin(); // because we need to use i later
for( ; i != v.end(); ++i ) {
    if( *i > x && *i < y ) break;
}

// C++11: use std::find_if
auto i = find_if( begin(v), end(v), [=](int i) { return i > x && i < y; } );

Jika anda ingin perulangan atau fitur bahasa yang serupa tetapi tidak tersedia. Tidak masalah. Anda dapat menuliskannya sebagai fungsi template (library algorithm) dan terima kasih kepada lambda anda bisa menggunakannya seolah olah hal tersebut fitur bahasa c++, dan lebih flexible karena merupakan library dan bukan merupakan fitur bahasa.

// 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 ...
});

Biasakan menggunakan lambda. Anda akan banyak menggunakannya, dan tidak hanya di c++, tetapi banyak bahasa popular lain yang sudah mengadopsinya. Anda dapat memulai belajar mengenai lambda dengan menonton presentasi Lambdas, Lambdas Everywhere at PDC 2010

Move / &&

Move dapat dianggap sebagai optimisasi dari copy, meskipun dapat digunakan juga untuk perfect forwarding

Move mengubah cara kita merancang API kita. Kita akan lebih sering melakukan return by value dibandingkan sebelumnya.

// C++98: alternatives to avoid copying
vector<int>* make_big_vector(); // option 1: return by pointer: no copy, but don't forget to delete
:::
vector<int>* result = make_big_vector();

void  make_big_vector( vector<int>& out ); // option 2: pass out by reference: no copy, but caller needs a named object
:::
vector<int> result;
make_big_vector( result );

// C++11: move
vector<int> make_big_vector(); // usually sufficient for 'callee-allocated out' situations
:::
auto result = make_big_vector(); // guaranteed not to copy the vector

Tambahkan move untuk tipe anda jika anda ingin melakukan sesuatu yang efisien dibandingkan copy.

Uniform Initialization and Initializer Lists

Hal yang tidak berubah adalah ketika kita melakukan inisialisasi terhadap variable local yang memiliki tipe Plain Old Data atau auto, kita akan tetap menggunakan = tanpa extra {}.

// C++98 or C++11
int a = 42;        // still fine, as always

// C++ 11
auto x = begin(v); // no narrowing or non-initialization is possible

Untuk kasus lain, anda akan menggantikan () untuk membuat object, dengan menggunakan {}. Menggunakan {} menghindarkan beberapa masalah, yaitu anda tidak akan mendapatkan konversi otomatis (float ke int) secara tidak disengaja, dan anda tidak akan mendapatkan variable atau array POD yang tidak terinisialisasi, dan anda akan menghindarkan kesalahan bahwa code anda dapat di compile tetapi yang mendeklarasikan fungsi dan bukan variable karena ambigu pada grammar c++( Scott Meyers menyebutnya sebagai “c++’s most vexing parse”. Tidak ada yang menjengkelkan dengan gaya yang baru ini.

// 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(), extents() };
complex<double> c   { 2.71828, 3.14159 };
int             a[] { 1, 2, 3, 4 };
vector<int>     v   { 1, 2, 3, 4 };

Sintaks {} dapat digunakan hampir dimana saja

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

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

Kadang-kadang lebih menyenangkan untuk melewatkan argument dari fungsi tanpa membuat tipe sementara.

void draw_rect( rectangle );

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

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

Satu-satunya tempat dimana {} tidak digunakan adalah untuk inisialisasi sederhana dari variable non-POD seperti auto x = begin(v);,
Dimana code akan menjadi lebih jelek jika kita melakukannya, karena kita tahu bahwa tidak perlu pusing dengan konversi, dan compiler modern akan melakukan optimisasi untuk mencegah extra copy (atau extra move jika type merupakan move-enabled)

Dan banyak lagi

Masih banyak lagi fitur yang belum dijelaskan. Much more. Dimasa depan saya akan menuliskan lebih detail mengenai fitur-fitur berikut dan fitur lain yang akan kita ketahui dan cintai
Tetapi untuk sekarang ini, ini adalah kumpulan dari fitur-fitur yang wajib kita ketahui. Fitur ini merupakan inti yang mendefinisikan gaya pemrogramam c++ yang baru, dimana kode c++menjadi lebih elegan dan akan digunakan dibanyak tempat. Fitur tersebut juga akan membuat modern c++ menjadi bahasa pemrogrman bersih, aman, dan cepat, tetap digunakan industry pada tahun-tahun mendatang.

C++ Major Books

Banyak sekali buku yang beredar mengenai c++. Kita tentu saja tidak dapat membacanya semua. Beberapa buku berikut merupakan buku yang direkomendasikan oleh Herb Sutter untuk dibaca melalui GoingNative 2012.

1. C++ Primer ( moo, stanley lippman )
2. The C++ Programming Language (stroustrup)
3. Programming : Principle & Practice using C++ (stroustrup)
4. Effective c++ (meyers)
5. C++ Coding Standards (sutter, alexandrescu)

Beberapa buku di atas akan release tahun ini. Tentu saja isi dari buku tersebut akan mencakup penambahan yang ada di c++11. Sedangkan beberapa buku lain masih harus kita tunggu bersama-sama karena tentu saja para penulis butuh belajar juga mengenai c++11.

Saran saya adalah untuk buku yang belum terbit silahkan baca buku versi sebelum, dan kemudian kita analisa apakah konsep yang diajarkan dalam buku tersebut masih relevant atau tidak untuk Modern C++.

Let’s Get Started from Now.