diff --git a/wiki/cpp-tutorial/language-basics.md b/wiki/cpp-tutorial/language-basics.md index c53530d..43cd0b0 100644 --- a/wiki/cpp-tutorial/language-basics.md +++ b/wiki/cpp-tutorial/language-basics.md @@ -48,8 +48,8 @@ you've written code a certain way. C++ has two types of comments: _Line comments_ or _single-line comments_ start with `//` and go until the end of the line. -_Block comments_ start with `/*` and end with `*/`. They don't actually have to be multiple lines long, but that's why -they're typically used instead of line comments. +_Block comments_ start with `/*` and end with `*/`. Although they can be used for single-line comments, they are +typically used for comments that span multiple lines. ## Statements @@ -57,7 +57,7 @@ In C++, we have many different types of statements. To start, we will discuss so ### Declaration Statements -Declaration statements "add stuff" to your program; doing so is called _declaring_. For example, we can declare +Declaration statements "add stuff" to your program. Doing so is called _declaring_. For example, we can declare _variables_. Once you have declared to your compiler that something exists, you can use it later in your program with other types of statements. @@ -66,11 +66,10 @@ other types of statements. int foo = 0; ``` -Breaking down the statement, we will start by identifying the name of the variable `foo`. To the left of `foo`, we see -the type of the variable, `int`. Variables in C++ are required to have a type in the declaration, and a variable cannot -change type after it is declared. The equals symbol (`=`) is used to provide the variable `foo` with a value. The right -side of the `=` statement is an expression used to specify the value to assign. In this case, we are assigning `foo` the -value of `0`. +Breaking down this statement, we will start by identifying the name of the variable, `foo`. To the left of `foo`, we see +the type of the variable, `int`. In C++, variables are required to have a type in the declaration, and a variable cannot +change its type after it is declared. The equals sign (`=`) gives `foo` its initial value. The expression on the right +side of the `=` specifies that value, which is `0` in this case. ### Expression Statements @@ -91,16 +90,17 @@ contain alphabetic characters, `_`, digits, and certain Unicode characters, but ::: info For Advanced Developers -While Unicode characters can be used in C++ identifiers, the degree of support for this has changed throughout the -years. Many C++ developers prefer to use only ASCII characters in their code, which is most portable and easiest to type -on all keyboards. For example, most developers would call a variable `alpha` instead of `α`. +While Unicode characters can be used in C++ identifiers, the degree of support for them has changed throughout the +years. Many C++ developers prefer to use only ASCII characters in their code, which is more portable and easier to type +on most keyboards. For example, most developers would name a variable `alpha` instead of `α`. ::: ## Keywords -C++ reserves a set of words in the language for its own use. Developers may use these keywords, but they cannot be used -as identifiers. You can find a list of all keywords on [cppreference](https://en.cppreference.com/w/cpp/keyword). +C++ reserves a set of words in the language for its own use, known as _keywords_. Developers may use these keywords, but +they cannot be used as identifiers (such as variable names). You can find a list of C++ keywords on +[cppreference](https://en.cppreference.com/w/cpp/keyword). ```cpp int my_integer_value = 0; // int is a keyword @@ -126,41 +126,40 @@ int foo = 0; ``` The above statement is one of the most common ways to initialize a variable. It gives the variable `foo` an initial -value of `0`. There are many ways to initialize a variable, each having its own pros and cons. The different types of -initialization will be discussed in more detail in another section. +value of `0`. There are many ways to initialize a variable in C++, each having its own pros and cons. The different +types of initialization will be discussed in more detail in a later section. -Assignment is a process that takes place after a variable already exists. It is the process of assigning a new value to -an existing variable. +Assignment happens _after_ a variable has been created. It is the process of giving an existing variable a new value. ```cpp int foo = 0; // initialization (begins with the type of the variable) foo = 2; // assignment (no type specified) ``` -Like initialization, assignment has several different forms that will be discussed in more detail in a later chapter. +Like initialization, assignment has several forms that will be discussed in more detail in a later chapter. ## Fundamental Data Types and Literals -All values in C++ have a _type_, and variables can only hold values of a specified type. +In C++, every value has a _type_, and a variable can only hold values of the type it was declared with. -The most simple types are _fundamental types_. You have already seen variables of (fundamental) type `int` in the -examples above, and values such as `0` (also of type `int`). We will go over some commonly used fundamental types in the -following section. +The simplest types are _fundamental types_. You have already seen variables of the fundamental type `int`, and values +such as `0`, which are also of type `int`. The following sections cover some commonly used fundamental types. ### `bool` -The type `bool` can either hold the values `true` and `false`. You can use it to store the result of logic, like: +The type `bool` holds a Boolean value, which is either `true` or `false`. You can use it to store the result of logical +expressions, like: ```cpp -bool b = 1 > 0; // True if one is greater than zero. +bool b = 1 > 0; // True if 1 is greater than 0. ``` ### Integer Types -_Integer types_ in C++ are similar to integers in math. They can store (possibly negative) whole numbers like `1` or -`-1`, but no fractions, like `0.5`. +_Integer types_ in C++ are similar to integers in math. They can store values like `1`, `0`, or `-1`, but not fractions +like `0.5`. -See below a list of _signed integer types_: +Below are the standard _signed integer types_: | Type | Minimum Range | Minimum Width in Bits | | ------------- | ------------------------------------------------------- | --------------------- | @@ -170,7 +169,7 @@ See below a list of _signed integer types_: | `long` | [−2,147,483,648, 2,147,483,647] | 32 | | `long long` | [−9,223,372,036,854,775,808, 9,223,372,036,854,775,807] | 64 | -Additionally, there are _unsigned integer types_, which cannot store negative values. +There are also _unsigned integer types_, which cannot store negative values. | Type | Minimum Range | Minimum Width in Bits | | -------------------- | ------------------------------- | --------------------- | @@ -183,7 +182,7 @@ Additionally, there are _unsigned integer types_, which cannot store negative va ::: info As seen in the table, these ranges are minimums, and the exact size can vary. For example, `int` and `unsigned int` are -usually 32-bit, so they're wider than the 16-bit minimum. `long` and `unsigned long` are 64-bit On 64-bit \*nix systems, +usually 32-bit, so they're wider than the 16-bit minimum. `long` and `unsigned long` are 64-bit on 64-bit \*nix systems, and 32-bit on Windows. The C++ standard library provides exact-width aliases like `std::int32_t`. @@ -192,9 +191,10 @@ The C++ standard library provides exact-width aliases like `std::int32_t`. ### Character Types -In addition to `signed char` and `unsigned char`, C++ has a type `char`. All three of these types are used for character -representation, and are one byte large. The standard does not specify if `char` is signed or unsigned, but is is a -distinct type. On x86-64, `char` is typically signed, whereas on ARM64, it is typically unsigned. +In addition to `signed char` and `unsigned char`, C++ has a type called `char`. All three of these types are used to +represent characters and are one byte in size. The standard does not specify whether `char` is signed or unsigned, but +it is a distinct type from both `signed char` and `unsigned char`. On x86-64, `char` is typically signed, and on ARM64, +it is typically unsigned. Throughout the years, further character types were added to C++: @@ -206,38 +206,38 @@ Throughout the years, further character types were added to C++: ### Floating-Point Types -A floating-point type can represent +A floating-point type can represent: - integers (e.g. `0`), - numbers with fractional parts (e.g. `0.5`), - positive or negative infinity, and - NaN (not a number). -However, since floating-point numbers are fixed-size, they can only represent certain fractional numbers exactly. For -example, `0.1` cannot be represented exactly by a floating-point number, and neither can be extremely tiny or extremely -large numbers. +Floating-point numbers have a fixed size, so they can only represent certain fractional numbers exactly. For example, +`0.1` cannot be represented exactly as a floating-point number. Each type also has a limited range, so extremely large +and extremely tiny numbers cannot be represented at all. -There are at least three fundamental floating-point types in C++: `float`, `double`, and `long double`. The range of -representable values for a `double` is required to be at least as large as that of a `float`, and the `long double` must -have a range at least that of a `double`. The language does not provide many strong guarantees about the properties of -the various floating-point types. +C++ provides at least three fundamental floating-point types: `float`, `double`, and `long double`. A `double` must have +a range at least as large as a `float`, and a `long double` must have a range at least as large as a `double`. Beyond +these requirements, the language does not provide many strong guarantees about the floating-point types. ::: info IEEE-754 Floating-Point Model -Because C++ needs to support many different types of computers, it does not enforce that floating-points are represented -in a specific way. For the sake of this tutorial, we will assume that you are working on a device that uses the IEEE-754 -floating-point specification. This is the case for almost all consumer hardware. The rest of the tutorial will make the -assumption that a `float` is an IEEE-754 binary32 format float and that a `double` is an IEEE-754 binary64 format float. +Because C++ supports many kinds of hardware, it does not require a specific floating-point representation. This tutorial +assumes that you are working on a device that uses the IEEE-754 floating-point specification, which is the case for +almost all consumer hardware. + +The rest of the tutorial assumes that a `float` is an IEEE-754 binary32 float and that a `double` is an IEEE-754 +binary64 float. | Type | Range | Width | | -------- | ---------------------- | ----- | | `float` | $\pm 3.402 * 10^{38}$ | 32 | | `double` | $\pm 1.797 * 10^{308}$ | 64 | -The type `long double` has the restriction that its range must be at least as large as a `double`. On many x86-64 -platforms, it is implemented as an IEEE-754 binary64 extended format, where the width of the type is 80 bits. However, -MSVC is an exception to this rule, where it is only 64 bits. On other platforms, it may be implemented as a IEEE-754 -binary128 format float. +On many x86-64 platforms, `long double` is an IEEE-754 binary64 extended format float, which is 80 bits wide. MSVC is an +exception, where `long double` is 64 bits, the same as `double`. On other platforms, it may be an IEEE-754 binary128 +float. ::: @@ -246,23 +246,22 @@ binary128 format float. Literals are a way that C++ allows us to provide a value directly in the code. You may recall above where the code snippets were creating variables using numbers in the code. Those numbers are referred to as literals. -Integer literals are just numbers in code with no trailing fractional part. By adding a `u`, you can tell the compiler -that the literal represents an unsigned integer type. Floating-point literals are numbers in code with a trailing -fractional part. Without a `f` at the end, the compiler will treat the number as a `double`. By adding a trailing `f`, -the compiler now treats it as a `float`. +- **Integer literals** are numbers with no fractional part (e.g. `3`). Adding a `u` suffix makes the literal unsigned + (e.g. `3u`). +- **Floating-point literals** are numbers with a fractional part (e.g. `3.14`). By default, the compiler treats them as + `double`. Adding an `f` suffix makes the literal a `float` (e.g. `3.14f`). ```cpp -int foo = 3; // This is an integer literal -int ufoo = 3u; // This is an unsigned integer literal -float bar = 3.14f; // This is a floating-point literal for a float -double baz = 3.14; // This is a floating-point literal for a double +int foo = 3; // This is an integer literal +unsigned int ufoo = 3u; // This is an unsigned integer literal +float bar = 3.14f; // This is a floating-point literal for a float +double baz = 3.14; // This is a floating-point literal for a double ``` ## Basic Operators -Operators are a type of expression that uses symbols to provide meaning. For example, `+` is an operator. As you may -have assumed, `+` is typically used to add values together. Here, we'll introduce a handful of operators that you can -use with the types you learned about above: +Operators are symbols that perform operations on values. For example, `+` is an operator that adds two values together. +Here are a handful of operators that you can use with the fundamental types covered above: | Operator | Name | Function | | -------- | -------------- | ----------------------------------------- | @@ -275,26 +274,31 @@ use with the types you learned about above: ::: info The Assignment Operator -As we saw above, the equal sign (`=`) can be used both for initializing a variable and for assigning new values to -variables. Even though both use `=`, it is important to remember there is a difference between initialization and -assignment of variables. The distinction between the two will be explored further in a later chapter. +As we saw above, the equals sign (`=`) is used both to initialize a variable and to assign a new value to an existing +variable. Initialization and assignment are different operations even though they use the same symbol. The distinction +between the two will be explored further in a later chapter. ::: In your exploration of the language so far, you may have noticed that there is a `^` operator. In math, you may think of -this as a power/exponentiation operator. In C++, this operator has a different meaning that will be discussed in a later -chapter on [bitwise operators](/cpp-tutorial/operators#bitwise-operators). +this as a power/exponentiation operator. In C++, the `^` operator means something else, which will be discussed in a +later chapter on [bitwise operators](/cpp-tutorial/operators#bitwise-operators). ## Wrapping Up -In the above sections, we've covered the basics of a C++ program. At this point, you should know the basics of how a C++ -program is structured, how to create a variable, some of the types that C++ provides you, and some of the operations -provided to you on those types. Additionally, you should be able to write a comment in your code. Let's bring this -together and write a simple program that changes Fahrenheit to Celsius. +We've now covered the basics of a C++ program. At this point, you should know: + +- how a C++ program is structured +- how to write comments +- how to create a variable +- some of the types that C++ provides +- some of the operations you can use on those types + +Let's put this into practice and write a simple program that converts Fahrenheit to Celsius. The equation to convert the two is very simple: $C = (F - 32) / (9 / 5)$. -Because temperature is not an integer value, but a real number, we will use `double` to store our variables. +Temperatures can have fractional parts, so we will use `double` to store our variables. ```cpp int main() {