Hello guys.This is an english forum about gaming, computer and technology.
 
HomeFAQSearchMemberlistUsergroupsRegisterLog in

Share | 
 

  C++ Basics For Beginners -Variables and types

View previous topic View next topic Go down 
AuthorMessage
MrElekid
Admin
avatar

Posts : 16
Prestige : 47
Join date : 2015-11-22
Age : 20
Location : United Kingdom

PostSubject: C++ Basics For Beginners -Variables and types   Sun Nov 22, 2015 6:18 pm

The usefulness of the "Hello World" programs shown in the previous lesson is rather questionable. We had to write several lines of code, compile them, and then execute the resulting program, just to obtain the result of a simple sentence written on the screen. It certainly would have been much faster to type the output sentence ourselves.

However, programming is not limited only to printing simple texts on the screen. In order to go a little further on and to become able to write programs that perform useful tasks that really save us work, we need to introduce the concept of variable.

Let's imagine that I ask you to remember the number 5, and then I ask you to also memorize the number 2 at the same time. You have just stored two different values in your memory (5 and 2). Now, if I ask you to add 1 to the first number I said, you should be retaining the numbers 6 (that is 5+1) and 2 in your memory. Then we could, for example, subtract these values and obtain 4 as result.

The whole process described above is a simile of what a computer can do with two variables. The same process can be expressed in C++ with the following set of statements:

Code:
a = 5;
b = 2;
a = a + 1;
result = a - b;
Obviously, this is a very simple example, since we have only used two small integer values, but consider that your computer can store millions of numbers like these at the same time and conduct sophisticated mathematical operations with them.

We can now define variable as a portion of memory to store a value.

Each variable needs a name that identifies it and distinguishes it from the others. For example, in the previous code the variable names were a, b, and result, but we could have called the variables any names we could have come up with, as long as they were valid C++ identifiers.


Identifiers


A valid identifier is a sequence of one or more letters, digits, or underscore characters (_). Spaces, punctuation marks, and symbols cannot be part of an identifier. In addition, identifiers shall always begin with a letter. They can also begin with an underline character (_), but such identifiers are -on most cases- considered reserved for compiler-specific keywords or external identifiers, as well as identifiers containing two successive underscore characters anywhere. In no case can they begin with a digit.

C++ uses a number of keywords to identify operations and data descriptions; therefore, identifiers created by a programmer cannot match these keywords. The standard reserved keywords that cannot be used for programmer created identifiers are:

alignas, alignof, and, and_eq, asm, auto, bitand, bitor, bool, break, case, catch, char, char16_t, char32_t, class, compl, const, constexpr, const_cast, continue, decltype, default, delete, do, double, dynamic_cast, else, enum, explicit, export, extern, false, float, for, friend, goto, if, inline, int, long, mutable, namespace, new, noexcept, not, not_eq, nullptr, operator, or, or_eq, private, protected, public, register, reinterpret_cast, return, short, signed, sizeof, static, static_assert, static_cast, struct, switch, template, this, thread_local, throw, true, try, typedef, typeid, typename, union, unsigned, using, virtual, void, volatile, wchar_t, while, xor, xor_eq

Specific compilers may also have additional specific reserved keywords.

Very important: The C++ language is a "case sensitive" language. That means that an identifier written in capital letters is not equivalent to another one with the same name but written in small letters. Thus, for example, the RESULT variable is not the same as the result variable or the Result variable. These are three different identifiers identifiying three different variables.


Fundamental data types


The values of variables are stored somewhere in an unspecified location in the computer memory as zeros and ones. Our program does not need to know the exact location where a variable is stored; it can simply refer to it by its name. What the program needs to be aware of is the kind of data stored in the variable. It's not the same to store a simple integer as it is to store a letter or a large floating-point number; even though they are all represented using zeros and ones, they are not interpreted in the same way, and in many cases, they don't occupy the same amount of memory.

Fundamental data types are basic types implemented directly by the language that represent the basic storage units supported natively by most systems. They can mainly be classified into:

Character types: They can represent a single character, such as 'A' or '$'. The most basic type is char, which is a one-byte character. Other types are also provided for wider characters.


Numerical integer types: They can store a whole number value, such as 7 or 1024. They exist in a variety of sizes, and can either be signed or unsigned, depending on whether they support negative values or not.


Floating-point types: They can represent real values, such as 3.14 or 0.01, with different levels of precision, depending on which of the three floating-point types is used.


Boolean type: The boolean type, known in C++ as bool, can only represent one of two states, true or false.


The types described above (characters, integers, floating-point, and boolean) are collectively known as arithmetic types. But two additional fundamental types exist: void, which identifies the lack of type; and the type nullptr, which is a special type of pointer. Both types will be discussed further in a coming lessons about pointers.


Declaration of variables


C++ is a strongly-typed language, and requires every variable to be declared with its type before its first use. This informs the compiler the size to reserve in memory for the variable and how to interpret its value. The syntax to declare a new variable in C++ is straightforward: we simply write the type followed by the variable name (i.e., its identifier). For example:

Code:
int a;
float mynumber;
These are two valid declarations of variables. The first one declares a variable of type int with the identifier a. The second one declares a variable of type float with the identifier mynumber. Once declared, the variables a and mynumber can be used within the rest of their scope in the program.
If declaring more than one variable of the same type, they can all be declared in a single statement by separating their identifiers with commas. For example:

Code:

int a, b, c;
This declares three variables (a, b and c), all of them of type int, and has exactly the same meaning as:

Code:
int a;
int b;
int c;
To see what variable declarations look like in action within a program, let's have a look at the entire C++ code:

Code:
// operating with variables

#include <iostream>
using namespace std;

int main ()
{
 // declaring variables:
 int a, b;
 int result;

 // process:
 a = 5;
 b = 2;
 a = a + 1;
 result = a - b;

 // print out the result:
 cout << result;

 // terminate the program:
 return 0;
}
4


Don't be worried if something else than the variable declarations themselves look a bit strange to you. Most of it will be explained in more detail in coming lessons, and if i forgot something or something still not clear feel free to ask.


Initialization of variables


When the variables in the example above are declared, they have an undetermined value until they are assigned a value for the first time. But it is possible for a variable to have a specific value from the moment it is declared. This is called the initialization of the variable.

In C++, there are three ways to initialize variables. They are all equivalent and are reminiscent of the evolution of the language over the years:

The first one, known as c-like initialization (because it is inherited from the C language), consists of appending an equal sign followed by the value to which the variable is initialized:

type identifier = initial_value;
For example, to declare a variable of type int called x and initialize it to a value of zero from the same moment it is declared, we can write:
Code:
int x = 0;
A second method, known as constructor initialization (introduced by the C++ language), encloses the initial value between parentheses (()):

type identifier (initial_value);
For example:

Code:

int x (0);
Finally, a third method, known as uniform initialization, similar to the above, but using curly braces ({}) instead of parentheses (this was introduced by the revision of the C++ standard, in 2011):

type identifier {initial_value};
For example:

Code:
int x {0};
All three ways of initializing variables are valid and equivalent in C++.

Code:
// initialization of variables

#include <iostream>
using namespace std;

int main ()
{
 int a=5;               // initial value: 5
 int b(3);              // initial value: 3
 int c{2};              // initial value: 2
 int result;            // initial value undetermined

 a = a + b;
 result = a - c;
 cout << result;

 return 0;
}
6


Type deduction: auto and decltype


When a new variable is initialized, the compiler can figure out what the type of the variable is automatically by the initializer. For this, it suffices to use auto as the type specifier for the variable:

Code:
int foo = 0;
auto bar = foo;  // the same as: int bar = foo;
Here, bar is declared as having an auto type; therefore, the type of bar is the type of the value used to initialize it: in this case it uses the type of foo, which is int.

Variables that are not initialized can also make use of type deduction with the decltype specifier:

Code:
int foo = 0;
decltype(foo) bar;  // the same as: int bar;
Here, bar is declared as having the same type as foo.

auto and decltype are powerful features recently added to the language. But the type deduction features they introduce are meant to be used either when the type cannot be obtained by other means or when using it improves code readability. The two examples above were likely neither of these use cases. In fact they probably decreased readability, since, when reading the code, one has to search for the type of foo to actually know the type of bar.


Introduction to strings


Fundamental types represent the most basic types handled by the machines where the code may run. But one of the major strengths of the C++ language is its rich set of compound types, of which the fundamental types are mere building blocks.

An example of compound type is the string class. Variables of this type are able to store sequences of characters, such as words or sentences. A very useful feature!

A first difference with fundamental data types is that in order to declare and use objects (variables) of this type, the program needs to include the header where the type is defined within the standard library (header <string>):

Code:
// my first string
#include <iostream>
#include <string>
using namespace std;

int main ()
{
 string mystring;
 mystring = "This is a string";
 cout << mystring;
 return 0;
}
This is a string

As you can see in the previous example, strings can be initialized with any valid string literal, just like numerical type variables can be initialized to any valid numerical literal. As with fundamental types, all initialization formats are valid with strings:

Code:
string mystring = "This is a string";
string mystring ("This is a string");
string mystring {"This is a string"};
Strings can also perform all the other basic operations that fundamental data types can, like being declared without an initial value and change its value during execution:

Code:
// my first string
#include <iostream>
#include <string>
using namespace std;

int main ()
{
 string mystring;
 mystring = "This is the initial string content";
 cout << mystring << endl;
 mystring = "This is a different string content";
 cout << mystring << endl;
 return 0;
}
This is the initial string content
This is a different string content

Note: inserting the endl manipulator ends the line (printing a newline character and flushing the stream).

The string class is a compound type. As you can see in the example above, compound types are used in the same way as fundamental types: the same syntax is used to declare variables and to initialize them.
Back to top Go down
View user profile http://cheatcountry.forumz.ro
 
C++ Basics For Beginners -Variables and types
View previous topic View next topic Back to top 
Page 1 of 1
 Similar topics
-
» Red Troll and Trollish Types
» Gaming basics and our responsibility
» The Arcana (Strengths of Arcana Types)
» RUST's Beginners Guide & Tips and Tricks
» The Basics for PhotoScape!

Permissions in this forum:You cannot reply to topics in this forum
CheatCountry :: Programming-
Jump to: