Quite a lot of questions that I can not answer in one post. Therefore, I will answer the questions in subsequent posts.<\/p>\n
But let me start with a non-asked question. Which programming paradigm does C++ support?<\/p>\n<\/p>\n
A strong simplification<\/h2>\n
40 years is a long time in software development. Therefore, it is no big surprise that C++ underwent many metamorphoses.<\/p>\n
C began in the early 70th of the last century. 1998 the first C++ standard was published. 13 years later, the area of modern C++ began with C++11. More interesting than the raw numbers is that each of these three steps stands for a different way of solving problems. In C, you think in procedures and structures. C++ introduces object orientation and generic programming, a new kind of abstraction. With C++11, we got the functional programming style.<\/p>\n
![\"ObjectOrientedGenericFunctional\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2017\/01\/ObjectOrientedGenericFunctional.png\")
<\/p>\n
<\/p>\n
Before I only write about functional programming, I will sketch the ideas of object-oriented, generic, and functional programming.<\/p>\n
Object-oriented programming<\/h3>\n
Object-oriented programming is based on the three concepts of encapsulation, inheritance, and polymorphism.<\/p>\n
- \n
- Encapsulation<\/dt>\n
- \n
An object encapsulates its attributes and methods and provides them via an interface to the outside world. This property that an object hides its implementation is often called data hiding.<\/em> <\/em><\/p>\n<\/dd>\n
- Inheritance<\/dt>\n
- \n
A derived class gets all characteristics from its base class. You can use an instance of a derived class as an instance of its base class. We often speak about code reuse<\/em> because the derived class automatically gets all characteristics of the base class.<\/p>\n<\/dd>\n
- Polymorphism<\/dt>\n
- \n
Polymorphism is the ability to present the same interface for differing underlying data types. The term is Greek and stands for many forms.<\/p>\n<\/dd>\n<\/dl>\n
<\/p>\n
\n\n\n
\n \n 1\r\n 2\r\n 3\r\n 4\r\n 5\r\n 6\r\n 7\r\n 8\r\n 9\r\n10\r\n11\r\n12\r\n13<\/pre>\n<\/td>\n
\n class<\/span> HumanBeing<\/span>{\r\npublic:\r\n HumanBeing(std::stringn):name(n){}\r\n virtual<\/span> std::string getName() const<\/span>{\r\n return<\/span> name;\r\n }\r\nprivate:\r\n std::string name;\r\n};\r\n\r\nclass<\/span> Man<\/span>: public<\/span> HumanBeing{};\r\n\r\nclass<\/span> Woman<\/span>: public<\/span> HumanBeing{}; \r\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/p>\n
In the example, you only get the name of HumanBeing<\/span> by using the method getName <\/span>in line 4 (encapsulation). <\/span>In addition, getName<\/span> is declared as virtual. Therefore, derived classes can change the behavior of their methods and therefore change the behavior of their objects (polymorphism). Man<\/span> and Woman<\/span> are derived from HumanBeing.<\/span><\/p>\n
Generic programming<\/h3>\n
The key idea of generic programming or programming with templates is to define families of functions or classes. You automatically get a function or class for this type by providing the concrete type. Generic programming provides a similar abstraction to object-oriented programming. A big difference is that the polymorphism of object-oriented programming will happen at runtime; that polymorphism of generic programming will happen in C++ at compile time. That is the reason why polymorphism at runtime is often called dynamic polymorphism but polymorphism at compile is often called static polymorphism.<\/p>\n
By using the function template, I can exchange arbitrary objects.<\/p>\n
<\/p>\n
\n\n\n
\n \n 1\r\n 2\r\n 3\r\n 4\r\n 5\r\n 6\r\n 7\r\n 8\r\n 9\r\n10\r\n11\r\n12<\/pre>\n<\/td>\n
\n template<\/span> <typename<\/span> T> void<\/span> xchg(T& x, T& y){ \r\n T t= x;\r\n x= y;\r\n y= t;\r\n};\r\nint<\/span> i= 10;\r\nint<\/span> j= 20;\r\nMan huber;\r\nMan maier;\r\n\r\nxchg(i,j);\r\nxchg(huber,maier);\r\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/p>\n
It doesn’t matter for the function template if I exchange numbers or men (lines 11 and 12). In addition, I have not specified the type parameter (line) because the compiler can derive it from the function arguments (lines 11 and 12).<\/p>\n
The automatic type deduction of function templates will not hold for class templates. In the concrete case, I must specify the type parameter T and the non-type parameter N (line 1).<\/p>\n
<\/p>\n
\n\n\n
\n \n 1\r\n 2\r\n 3\r\n 4\r\n 5\r\n 6\r\n 7\r\n 8\r\n 9\r\n10\r\n11\r\n12\r\n13\r\n14\r\n15<\/pre>\n<\/td>\n
\n template<\/span> <typename<\/span> T, int<\/span> N>\r\nclass<\/span> Array<\/span>{\r\npublic:\r\n int<\/span> getSize() const<\/span>{\r\n return<\/span> N;\r\n }\r\nprivate:\r\n T elem[N];\r\n};\r\n \r\nArray<double<\/span>,10> doubleArray;\r\nstd::cout << doubleArray.getSize() << std::endl;\r\n\r\nArray<Man,5> manArray;\r\nstd::cout << manArray.getSize() << std::endl;\r\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/p>\n
Accordingly, applying the class template Array<\/span> is independent of whether I use doubles<\/span> or men.<\/span><\/p>\n
Functional programming<\/h3>\n
I will only say a few words about functional programming because I will and can not explain the concept of functional programming in a short remark. Only that much. I use the code snippet of the pendants in C++ for the typical functions in functional programming: map, filter, and reduce. These are the functions std::transform,<\/span> std::remove_if,<\/span> and std::accumulate<\/span>.<\/p>\n
<\/p>\n
<\/p>\n
\n\n\n
\n \n 1\r\n 2\r\n 3\r\n 4\r\n 5\r\n 6\r\n 7\r\n 8\r\n 9\r\n10\r\n11\r\n12\r\n13\r\n14\r\n15\r\n16<\/pre>\n<\/td>\n
\n std::vector<int<\/span>> vec{1,2,3,4,5,6,7,8,9};\r\nstd::vector<std::string> str{\"Programming\"<\/span>,\"in\"<\/span>,\"a\"<\/span>,\"functional\"<\/span>,\"style.\"<\/span>};\r\n\r\nstd::transform(vec.begin(),vec.end(),vec.begin(),\r\n [](int<\/span> i){ return<\/span> i*i; }); \/\/ {1,4,9,16,25,36,49,64,81}<\/span>\r\n\r\nauto<\/span> it= std::remove_if(vec.begin(),vec.end(),\r\n [](int<\/span> i){ return<\/span> ((i < 3) or (i > 8)) }); \/\/ {3,4,5,6,7,8}<\/span>\r\nauto<\/span> it2= std::remove_if(str.begin(),str.end(),\r\n [](string s){ return<\/span> (std::lower(s[0])); }); \/\/ \"Programming\"<\/span>\r\n\r\n\r\nstd::accumulate(vec.begin(),vec.end(),[](int<\/span> a,int<\/span> b){return<\/span> a*b;}); \/\/ 362880<\/span>\r\nstd::accumulate(str.begin(),str.end(),\r\n [](std::string a,std::string b){return<\/span> a + \":\"<\/span>+ b;});\r\n \/\/ \"Programming:in:a:functional:style.\"<\/span>\r\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/p>\n
I apply in the code snippet two powerful features of functional programming. Both are mainstream in modern C++: automatic type deduction with auto<\/span> and lambda functions.<\/p>\n
What’s next?<\/h2>\n