Chapter 01: Towards Modern C++

Compilation Environment: This book will use clang++ as the only compiler used, and always use the -std=c++2a compilation flag in your code.

  1. > clang++ -v
  2. Apple LLVM version 10.0.1 (clang-1001.0.46.4)
  3. Target: x86_64-apple-darwin18.6.0
  4. Thread model: posix
  5. InstalledDir: /Library/Developer/CommandLineTools/usr/bin

1.1 Deprecated Features

Before learning modern C++, let’s take a look at the main features that have been deprecated since C++11:

Note: Deprecation is not completely unusable, it is only intended to imply that programmers will disappear from future standards and should be avoided. However, the deprecated features are still part of the standard library, and most of the features are actually “permanently” reserved for compatibility reasons.

  • The string literal constant is no longer allowed to be assigned to a char *. If you need to assign and initialize a char * with a string literal constant, you should use const char * or auto.

    1.   char *str = "hello world!"; // A deprecation warning will appear

  • C++98 exception description, unexpected_handler, set_unexpected() and other related features are deprecated and should use noexcept.

  • auto_ptr is deprecated and unique_ptr should be used.

  • register keyword is deprecated and can be used but no longer has any practical meaning.

  • The ++ operation of the bool type is deprecated.

  • If a class has a destructor, the properties for which it generates copy constructors and copy assignment operators are deprecated.

  • C language style type conversion is deprecated (ie using (convert_type)) before variables, and static_cast, reinterpret_cast, const_cast should be used for type conversion.

  • In particular, some of the C standard libraries that can be used are deprecated in the latest C++17 standard, such as <ccomplex>, <cstdalign>, <cstdbool> and <ctgmath> Wait

  • … and many more

There are also other features such as parameter binding (C++11 provides std::bind and std::function), export, and etc. are also deprecated. These features mentioned above If you have never used or heard of it, please don’t try to understand them. You should move closer to the new standard and learn new features directly. After all, technology is moving forward.

1.2 Compatibilities with C

For some force majeure and historical reasons, we had to use some C code (even old C code) in C++, for example, Linux system calls. Before the advent of modern C++, most people talked about “what is the difference between C and C++”. Generally speaking, in addition to answering the object-oriented class features and the template features of generic programming, there is no other opinion, or even a direct answer. “Almost” is also a lot of people. The Wayne diagram in Figure 1.2 roughly answers the C and C++ related compatibility.

Figure 1.2: Compatabilities between ISO C and ISO C++

From now on, you should have the idea that “C++ is not a superset of C” in your mind (and not from the beginning, later [References for further reading] (# further reading references) The difference between C++98 and C99 is given). When writing C++, you should also avoid using program styles such as void* whenever possible. When you have to use C, you should pay attention to the use of extern "C", separate the C language code from the C++ code, and then unify the link, for instance:

  1. // foo.h
  2. #ifdef __cplusplus
  3. extern "C" {
  4. #endif
  6. int add(int x, int y);
  8. #ifdef __cplusplus
  9. }
  10. #endif
  12. // foo.c
  13. int add(int x, int y) {
  14.     return x+y;
  15. }
  17. // 1.1.cpp
  18. #include "foo.h"
  19. #include <iostream>
  20. #include <functional>
  22. int main() {
  23.     [out = std::ref(std::cout << "Result from C code: " << add(1, 2))](){
  24.         out.get() << ".\n";
  25.     }();
  26.     return 0;
  27. }

You should first compile the C code with gcc:

  1. gcc -c foo.c

Comple and output the foo.o file, and link the C++ code to the .o file using clang++ (or both compile to .o and then unlink them together):

  1. clang++ 1.1.cpp foo.o -std=c++2a -o 1.1

Of course, you can use Makefile to compile the above code:

  1. C = gcc
  2. CXX = clang++
  4. SOURCE_C = foo.c
  5. OBJECTS_C = foo.o
  7. SOURCE_CXX = 1.1.cpp
  9. TARGET = 1.1
  10. LDFLAGS_COMMON = -std=c++2a
  12. all:
  13.     $(C) -c $(SOURCE_C)
  14.     $(CXX) $(SOURCE_CXX) $(OBJECTS_C) $(LDFLAGS_COMMON) -o $(TARGET)
  15. clean:
  16.     rm -rf *.o $(TARGET)

Note: Indentation in Makefile is a tab instead of a space character. If you copy this code directly into your editor, the tab may be automatically replaced. Please ensure the indentation in the Makefile. It is done by tabs.

If you don’t know the use of Makefile, it doesn’t matter. In this tutorial, you won’t build code that is written too complicated. You can also read this book by simply using clang++ -std=c++2a on the command line.

If you are new to modern C++, you probably still don’t understand the following small piece of code above, namely:

  1. [out = std::ref(std::cout << "Result from C code: " << add(1, 2))](){
  2.     out.get() << ".\n";
  3. }();

Don’t worry at the moment, we will come to meet them in our later chapters.

Table of Content | Previous Chapter | Next Chapter: Language Usability Enhancements

Further Readings

Licenses

Creative Commons License
This work was written by Ou Changkun and licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International License. The code of this repository is open sourced under the MIT license.