Archive

Archive for the ‘c++’ Category

Elements of Modern C++ Style

March 4, 2012 1 comment

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.

Categories: c++, C++11, Visual C++ Tags: , ,

Modern C++ : Memory Management

March 4, 2012 Leave a comment

Sudah bukan rahasia lagi kalau pemrograman c++ selalu ditakuti oleh karena kerumitan dalam melakukan memory management.
Jika kita mengalokasikan memory untuk object yang berada di Heap maka kita harus secara manual melakuan deallocate terhadap memory tersebut.
Banyak masalah yang dapat disebabkan oleh manual memory management ini

Tetapi kabar gembiranya adalah mimpi buruk memory management tersebut tidak sepenuhnya benar lagi untuk zaman ini. Memory management
dengan menggunakan modern c++ sudah jauh berbeda dengan yang dulu anda kenal.

Saya membuat beberapa video tutorial untuk menjelaskan secara ringkas beberapa hal baru di modern c++ dalam pengunaan memory management.

Enjoy it !

 

 

Categories: c++, C++11, Visual C++

C++ Major Books

March 4, 2012 Leave a comment

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.

 

 

Categories: c++, C++11 Tags: , ,

Windows Programming Curriculum

March 1, 2012 1 comment

Apa2 saja pengetahuan yang dibutuhkan agar dapat menjadi expert dalam Windows ?

Windows 7 Era

C

C++, STL and Boost

Win32 Programming

MFC

COM

ATL

C++/CLI

DirectX for Game programming

C# and .NET Platform

Windows 8 Era

WinRT and MetroStyle

C#, HTML 5, XAML, Javascript

C++/CX

DirectX for Game programming

Banyak sekali bukan yang harus dipelajari ? That’s our life i think. 🙂 Enjoy it!

Visual Studio C++ 2011 Preview

February 25, 2012 Leave a comment

Bagi para developer c++ mungkin sudah lama menanti2kan tools yang membantu development dengan c++. Dari maslah tools memang c++ sudah cukup ketinggalan. Visual Studio c++ 2011 akan memberikan tambah2n tools yang dapat meningkatkan produktifitas anda dalam keseharian

 

 

 

Keep watching. 🙂

C++ Memory Management Series

February 25, 2012 Leave a comment

Memory management merupakan salah satu hal yang menjadi momok untuk para developer. Melalui video ini saya akan menjelaskan bagaimana cara untuk menangani masalah tersebut dengan elegan.

 

 

 

Enjoy it!

Clang – C++ Smart Compiler

February 23, 2012 Leave a comment

Presentasi dari Chandler Carruth yang bisa kita lihat di GoingNative mengenai Clang compiler sangat persuasif sekali. Chandler menjelaskan kelemahan dari compiler sebelum seperti gcc dsb. Sering kali error yang dikeluar kan oleh compiler c++ akan membuat frustasi dari programmer pemula. Diagnostic yang dikeluarkan sukar dimengerti, bahkan mungkin sama sekali tidak membantu kita dalam mengalanalisa masalah. Compiler juga sering sekali melewatkan kesalahan2 yang terjadi meskipun secara syntax benar tetapi  logical nya salah atau bahkan tidak ada artinya.

Clang dalam hal ini dibuat berdasarkan masalah tersebut. Clang memberikan pesan error, warning dan diagnosa yang sangat baik untuk kesalahan, bad practice, and suggestion. This is really cool stuff. Sayangnya support untuk windows tidak begitu bagus dan buggy.

Clang juga mendukung c++11 yang sudah di approved oleh komite standard sejak akhir tahun lalu. Sehingga ini benar2 cukup menggoda sekali untuk dicoba. :). Dukungan yang diberikan Clang terhadap c++11 cukup lengkap. Anda dapat melihat perbandingannya dengan compiler2 lain di beberap situs berikut

http://stackoverflow.com/questions/7232878/c11-compiler-closest-to-the-standard-and-how-close

https://wiki.apache.org/stdcxx/C%2B%2B0xCompilerSupport

http://www.aristeia.com/C++11/C++11FeatureAvailability.htm

Saya mengikuti langkah yang ada di Getting Started atau di sini untuk melakukan build compiler Clang dengan Visual Studio c++. Kita akan melakukan compilasi compiler. That’s really cool isn’t ? c++ compiles c++ compilers. Proses kompilasi akan memakan waktu yang cukup lama. That’s compiler right ? not a common software. Jadi saya harap anda bersabar pada saat kompilasi dilakukan. Saya disini hanya akan melakukan build terhadap clang project sebagai compiler.

Hasil kompilasi tersebut akan ditemukan build\bin\Debug. Anda dapat melihat bahwa kompilasi tersebut menghasilkan clang.exe. Ini merupakan compiler yang akan kita gunakan untuk source code kita.

Seperti biasa saya akan mulai membuat program hello.cpp. Anda terlebih dahulu harus menambahkan compiler tersebut pada environment variable PATH.

#include
int main(int argc, char **argv) { printf("hello world\n"); }

Lakukan kompilasi dari command prompt

clang hello.c -o hello.exe

Anda dapat melihat hello.exe di generate. Jika anda mengeksekusinya maka akan segera ditampilkan Hello World ke layar. Tidak mengejutkan. 🙂

Sekarang kita akan membuktikan kecangihan dari Clang seperti yang ada di presentasi tersebut. Apakah benar Clang ini dapat menghasilkan diagnostic yang bagus ?

buat code add.cpp seperti berikut

int foo() {
   4 + 4;
}

Lakukan kompilasi dengan clang add.cpp -o add.exe. Maka akan ditampilkan pesan sebagai berikut

add.cpp:2:6: warning: expression result unused [-Wunused-value]
4 + 4;
~ ^ ~
add.cpp:3:1: warning: control reaches end of non-void function [-Wreturn-type]
}
^

Pesan warning yang diberikan cukup jelas. Very Cool.

Contoh lain adalah mengenai mengakses index array.

int foo() {
 int arr[100];

 return arr[100];
}

Maka kita akan mendapatkan error yang sangat deskriptif berikut ini

array.cpp:4:9: warning: array index 100 is past the end of the array (which
 contains 100 elements) [-Warray-bounds]
 return arr[100];
 ^ ~~~
 array.cpp:2:2: note: array 'arr' declared here
 int arr[100];
 ^
 1 warning generated.

Anda dapat mencoba contoh2 lain yang ada di presentasi Chandler tersebut. Ini sangat membantu bagi para beginner c++ untuk belajar. Clang akan membantu mengkoreksi code anda. Sehingga anda tidak menembak kaki anda sendiri dengan segala kebebasan yang ada di c++.

Saya mencoba menjalakan range for (c++11) dengan Clang. Tetapi gagal. Memang benar support untuk windows buggy. :(. Mudah2n segera dibenahi.

Jika anda ingin menggabungkan dengan visual studio. Anda dapat melakukan instalasi pluginsnya.

https://github.com/ishani/ClangVSx
http://stackoverflow.com/questions/4687789/use-clang-with-msvc-2010
http://stackoverflow.com/questions/2487931/llvm-c-ide-for-windows 

Enjoy it..

Categories: c++, C++11, Clang, Compiler