I liked C programming, as it is low level and the compiler is widely available. Using C language can demonstrate the understanding of pointer and memory. You can implement a linked list or a hash table by using C. So that you can understand better how the linked list and hash table work.

But as long as you want to build some end user applications, C language is never a good choice. Choosing a language for our product is important. We do not develop a web application using low level programming language. It is totally impractical.

C and C++

Do not think that C language is an old language. It can survive until today because it has some powerful features (yet I cannot name them out, because I am not a C developer). There are new features on C99 and C11. But practically to solve higher level problem like game development, C++ is much more better than C. (But there is a better choice like Lua.)

Syntax

Why is C++ better than C? From the syntax level, it is easier to read and easier to write. For example,

[code language=“c”] strtolower(trim(myString)); [/code]

where myString is a C string, then trim() is a function that returns trimmed string, strtolower() is another function that returns the string with lower case. (The function names I used here is based on PHP.) So, we can see, when we read or write, we need to read from right to left: trim then strtolower. And the parentheses needs to be matched properly.

On the other hand for C++,

[code language=“cpp”] myString->trim()->strtolower(); [/code]

Let’s say myString is a customized object, namely MyString, that manipulates the string. So, the syntax is much more intuitive. myString calls the trim() method and returns the MyString object, so that we can continue with strtolower() that returns MyString object. This is called method chaining.

Object oriented

Object oriented is a wondrous invention! It is so powerful that most programming languages today support object oriented. Inheritance, polymorphoism, and interface, these features reduce a lot of tremendous works. You can implement object oriented in C (using library such as GObject), but C language is not designed for object oriented.

Because of syntax and the object oriented, I prefer C++ than C.

String

Another advantage of C++ is the string. C string is an array of character, with the fixed size. It is not dynamic as C++ string. For example, you want to perform strcat(), you need to have a larger buffer to store the strcat() result. And if you want to do it with dynamic memory allocation, then you have to free the memory manually. This is exhaustive.

Object method

Related to method chaining, in C++ we can write the methods. In C, because it is using struct, to implement something like method is troublesome. For example,

[code language=“c”] #include <stdio.h> #include <stdlib.h>

typedef struct { int a; int (*b)(int a); } MyType;

int myTypeMethod(int a) { return a+20; }

MyType* myTypeNew() { MyType* myType = (MyType*)malloc(sizeof(MyType)); myType->a = 20; myType->b = myTypeMethod; //There is no method in struct, so we assign the callback function return myType; }

void myTypeDelete(MyType** myType) { free(*myType); *myType = NULL; }

int main(int argc, char** argv) { MyType* myType = myTypeNew(); printf("%d\n", myType->a); printf("%d\n", myType->b(20)); myTypeDelete(&myType); return 0; } [/code]

Because C doesn’t have namespace, but we can do something like namespace by using prefix.

C++11, C++14, C++1z

If you are not C++ lover, you may think that C++ is an archaic programming language. Just like HTML and JavaScript, there are ongoing proposals for the new features for C++. That is why, C++ is not dying yet. There are some notable features I need to state here.

New syntax

“auto” data type

[code language=“cpp”] #include #include using namespace std;

int main(int argc, char** argv) { int a = 10; auto b = a; cout « b « endl; cout « typeid(b).name() « endl; //“i” as integer float c = 20.0f; b = c; cout « b « endl; cout « typeid(b).name() « endl; //Still “i” return 0; } [/code]

“auto” is just like “var” in C#.

foreach

Most modern programming languages allows foreach keyword, like JavaScript, PHP, and even Python. Though Python uses “for” keyword, it works actually like foreach in PHP.

[code language=“cpp”] #include using namespace std; int main(int argc, char** argv) { int a[] = { 4, 5, 3, 2, 1 }; for(auto item : a) { cout « item « endl; } return 0; } [/code]

Another foreach,

[code language=“cpp”] #include #include #include using namespace std;

int main(int argc, char** argv) { vector a{ 4, 5, 3, 2, 1 }; for_each(a.begin(), a.end(), [](auto &item) { cout « item « endl; }); return 0; } [/code]

The above code can only be compiled with c++14 standard. If using c++11 standard, we must use “int” instead of “auto”.

Lambda expression

Lambda expression, a.k.a anonymous function. If you are working with JavaScript, such as

[code language=“javascript”] var a = [ 4, 5, 3, 2, 1 ]; var found = a.find(function(item) { if(item == 2) return item; }); [/code]

So, the above example shows that the parameter of the find() is a function, without a function name. This is a common syntax in functional programming. Functional programming is a trend of most modern programming language. The anonymous function is also supported by PHP. The advantage of functional programming is the elimination of side effects and avoiding changing state of the data. Therefore, it is a good paradigm for parallel programming.

Therefore, looking at the example above, there is some syntax like,

[code language=“cpp”] ([](int b) { cout « b « endl; })(12); [/code]

Which is similar to JavaScript,

[code language=“javascript”] (function(b) { console.log(b); })(12); [/code]

In C++, the squared bracket is used to capture the variable of the scope. (I think it is similar to PHP “using” keyword.)

Previously, we can use the callback function like,

[code language=“cpp”] #include using namespace std;

int foo(int (*cb)(int, void*), int size, void* data) { return cb(size, data); }

int callback(int size, void* data) { int sum = 0; int* intData = (int*)data; //typecast for(int i=0;i<size;i++) { sum += intData[i]; cout « intData[i] « endl; } return sum; }

int main(int argc, char** argv) { int a[] = { 4, 5, 3, 2, 1 }; int sum = foo(callback, 5, a); cout « sum « endl; return 0; } [/code]

Since we can use anonymous function, we need not to create a callback function like above. This can be written as,

[code language=“cpp”] #include using namespace std;

int foo(int (*cb)(int, void*), int size, void* data) { return cb(size, data); }

int main(int argc, char** argv) { int a[] = { 4, 5, 3, 2, 1 }; int result = foo([](int size, void* data) { int sum = 0; int* intData = (int*)data; for(int i=0;i<size;i++) { sum+= intData[i]; cout « intData[i] « endl; } return sum; }, 5, a); cout « result « endl; return 0; } [/code]

Multi-threading, asynchronous programming, promise

We can implement multi-threading using other libraries like pthread. But with C++11, you can create thread without third party libraries, perform sleep, sleep by milliseconds or even nanoseconds. There is also library for mutex (mutually exclusive).

C++11 also supports asynchronous programming like C# and promise like JavaScript. With the lambda expression, the syntax shares some similarities with C# and JavaScript. With async, we can do something at the background (using thread), and use the result later. With promise, you can promise to return some value, else throw an exception.

Regular expression

Regular expression is so important for text processing. C++11 supports regular expression. There are different regular expression syntax: BRE (basic regular expression) is the default syntax used by “grep” command, ERE (extended regular expression, and Perl regular expression. Perl regular expression is very powerful. If you use Python, JavaScript, Ruby, and C#, you will find that they have different syntax.

However, interestingly C++ uses ECMAScript regular expression syntax by default (though we can choose BRE, ERE, or awk). That means, if you know JavaScript RegExp, then you will have no problem with C++ regex.

(I see the converging features of the different programming languages, which means these features are useful, intuitive, and influential.)

 

Garbage collection

So far, there is no good garbage collection for C++.

 

Another thing I have to state. Because of the networking and big data, parallel programming is a demand and the trend. To make sure the data is immutable, functional programming becomes handy.

• C