2A. No Ducks Allowed – Types and Deduction

Learning Objectives

By the end of this chapter, you will be able to:

• Implement your own classes that behave like built-in types
• Implement classes that control which functions the compiler creates (Rule of Zero/Rule of Five)
• Develop functions using auto variables, like you always have
• Implement classes and functions by making use of strong typing to write safer code

This chapter will give you a good grounding in the C++ type system and allow you to write your own types that work in that system.

Introduction

C++ is a strongly typed, statically typed language. The compiler uses type information related to the variables that are used and the context in which they are used to detect and prevent certain classes of programming errors. This means that every object has a type and that type does not change, ever. In contrast, dynamically typed languages such as Python and PHP defer this type checking until runtime (also known as late binding), and the type of a variable may change during the execution of the application. These languages use the duck test instead of the variables type – that is, "if it walks and talks like a duck, then it must be a duck." Statically typed languages such as C++ rely on the type to determine whether a variable can be used for a given purpose, while dynamically typed languages rely on the presence of certain methods and properties to determine its suitability.

C++ was originally described as "C with classes". What does this mean? Basically...

C++ Types

As a strongly and, statically typed language, C++ provides several fundamental types and the ability to define their own types with as much or as little functionality as needed to solve the problem at hand. This section will start by introducing the fundamental types, initializing them, declaring a variable, and associating a type with it. We will then explore how to declare and define a new type.

C++ Fundamental Types

C++ includes several fundamental types, or built-in types. The C++ standard defines the minimum size in memory for each type and their relative sizes. The compiler recognizes these fundamental types and has built-in rules that define what operations can and cannot be performed on them. There are also rules for implicit conversions between types; for example, conversion from an int type to a float type.

Note

See the Fundamental Types section at https://en.cppreference.com/w/cpp/language/types for a brief description of all the built-in types.

C++ Literals

C++ literals are...

Specifying Types – Variables

As C++ is a statically typed language, it is necessary to specify the type of a variable when it is declared. When you declare a function, it is necessary to specify the return type and the types of arguments that are being passed to it. There are two choices for specifying the type to a variable when you declare it:

• Explicitly: You, as the programmer, are dictating exactly what the type is.
• Implicitly (using auto): You are telling the compiler to look at the value that was used to initialize the variable and determine its type. This is known as (auto) type deduction.

The general form of declaration for a scalar variable is one of the following:

type-specifier var;                       // 1. Default-initialized variable

type-specifier var = init-value;          // 2. Assignment initialized...

Specifying Types – Functions

Now that we can declare a variable to be of a certain type, we need to do something with those variables. In C++, we do things by calling a function. A function is a sequence of statements that deliver an outcome. That outcome could be a mathematical calculation (for example, an exponent) that is then sent to a file or written to a Terminal.

Functions allow us to break our solution into sequences of statements that are easier to manage and understand. As we write these packaged statements, we can reuse them where it makes sense. If we need it to operate differently based on the context, then we pass in an argument. If it returns a result, then the function needs a return type.

As C++ is a strongly typed language, we need to specify the types related to the functions that we implement – the type of value returned by the function (including no return) and the type of argument(s) that are passed to it, if any.

The following is a typical hello world...

Creating User Types

The great thing about C++ is that you can create your own types using struct, class, enum, or union and the compiler will treat it as a fundamental type throughout the code. In this section, we will explore creating our own type and the methods that we need to write to manipulate it, as well as some methods that the compiler will create for us.

Enumerations

The simplest user-defined type is the enumeration. Enumerations got an overhaul in C++11 to make them even more type-safe, so we have to consider two different declaration syntaxes. Before we look at how to declare them, let's figure out why we need them. Consider the following code:

int check_file(const char* name)

{

  FILE* fptr{fopen(name,"r")};

  if ( fptr == nullptr)

    return -1;

  char buffer[120];

  auto numberRead = fread(buffer, 1, 30, fptr);

  fclose(fptr);

  if (numberRead != 30)

    return -2;

 ...

Summary

In this chapter, we learned about types in C++. Firstly, we touched on the built-in types and then learned how to create our own types that behave like the built-in types. We learned how to declare and initialize variables, got a glimpse of what the compiler generates from the source, where it puts variables, how the linker puts it together, and then what that looks like in the computer's memory. We learned some of the C++ tribal wisdom around the Rule of Zero and the Rule of Five. These form the building blocks of C++. In the next chapter, we will look at creating functions and classes with C++ templates and explore further type deduction as it applies to templates.