C++ Variable
In C++, a variable is an address assigned to a value, or, to be precise, a name given to a memory address that holds a value during the program’s execution. A variable can be defined as a data item that can take different values at different times during the program. It can be a number, text or a more complex data structure. Other variables would depend on this fixed number for certain calculations or modulations during the program execution.
When working with C++, you will notice that creating a variable involves defining it using a specific type. For instance, in such a case as a variable, its descriptors tell a compiler what it is going to contain. Moreover, it is also important to note that when multiple variables are added, they should be given different names based on the restrictions or rules that each language possesses. Most of these rules require that the name must start with either a letter or an underscore and may end with letters, digits, or underscores. It should also be noted that variable names are case sensitive, hence it follows that myVariable and myvariable are two distinct variables.
Data Types in C++
Applying any contact where there’s interaction with variables within C++ language, it’s good to understand what data types constitute a variable in such a case. C++ allows numerical data representation for all weight classifications, moreover, a classification system through weight classification is also provided. There are three main categories of data types in C++, which are, but not limited to derived types and primitive types:
1. Primitive Data Types:
These are basic types which are supported in C++, namely:
- Integer Types: It is often referred to as a set used for the data that comprises whole numbers most specifically int (widely used), short (smaller whole numbers), and long (less whole numbers).
- Floating Point Types: The usage of a decimal in a number is possible through floating point types. In addition, there are `float`, which is all for single-precision numbers, and `double` for double-precision numbers, which can be expected to have more accurate digits.
- Character Type: A single element such as a letter, digit or any other symbol is stored using the `char` type. Each character is represented as a numerical value, which is the ASCII code of the character.
- Boolean Type: In computer programs, the `bool` type allows only the two boolean values - `true` and `false`.
2. Derived Data Types:
They are constructed out of the primitive types and as a matter of fact they are called derived types. Some of them are:
- Arrays: When data is stored in an array, the array contains variables of the same type and the variables are stored in a sequence in the computer’s memory.
- Pointers: What the pointer does is store the address of one variable in a different variable.
3. User-Defined Data Types:
More complex structures in a program may be implemented as user-defined datatypes which were defined by the programmer. Such datatypes are:
- Structures: A structure is defined as a data type that contains a group of other data types and allows for storing a lot of variables under a single name.
- Unions: With a union, you can set one or more data types at one address but only one data type can be set at that address at once.
- Enumerations: An enumeration is a set of user-defined types which comprises named integer values.
Operators in C++
Operators are the symbols which perform certain operations on variables and values in C++. They aid you in making calculations by using arithmetic, logical and even bitwise operators. C++ offers a number of operator classifications which contain:
1. Arithmetic Operators:
These operators are used to make any form of calculations. The most frequently used arithmetic operators are:
- Additive or simply Plus (`+`)
- Subtractive or simply Minus (`-`)
- Standard Multiplicative operator (`*`)
- The Division operator (`/`)
- The Modulus operator (`%`) - The output is the remainder left after the division operation is performed.
2. Relational Operators:
Comparing two values with relational operators is possibly the most basic function of any programming language. Depending on the outcome of the comparison, this set of functions returns a boolean value – a “true” or a “false”. The following are the most common relational operators and their symbols:
- Equal to (`==`)
- Not equal to (`!=`)
- Greater than (`> `)
- Less than (`<`)
- Greater than or equal to (`> =`)
- Less than or equal to (`<=`)
3. Logical Operators:
Whenever any complex condition has to be written, logical operators are used. Also, the function of logical operators is to combine other conditions or negate them. The most common logical operators are:
- AND (`&&`)
- OR (`||`)
- NOT (`!`)
4. Assignment Operators:
These are the operators that assign values to the variables in any program. The most commonly used assignment operator is equal to sign (`=`) but other operators also exist that combine assignment with other operations:
- Addition assignment (`+=`)
- Subtraction assignment (`-=`)
- Multiplication assignment (`*=`)
- Division assignment (`/=`)
5. Increment and Decrement Operators:
In order for a variable to be increased or decreased in value by one, this category of operators is used:
- Increment (`++`): Used when the value of a variable is to be increased by 1.
- Decrement (`--`): Used when there is a decrease in the value of the variable by 1.
6. Bitwise Operators:
The tasks are executed on the bits of an integer instead of on the integer as a whole thanks to bitwise operators. Some of them include:
- AND (`&`)
- OR (`|`)
- XOR (`^`)
- NOT (`~`)
- Left shift (`<<`)
- Right shift (`> > `)
7. Conditional (Ternary) Operator:
The word ternary is derived from the word three. The conditional operator is a more ideal way of writing an “if-else” statement as it condenses the structure into three parts:
- `condition ? expression1 : expression2;`
A condition dictates that the operator evaluates. If true, `expression1` is executed, else `expression2` is executed.
