Introduction to Operators and Operands
Introduction to Operators and Operands
Fundamentals of Operators and Operands
An Operation
An operation is an action performed on one or more values either to modify the value held by one or both of the variables or to produce a new value by combining variables. Therefore, an operation is performed using at least one symbol and one value.
An Operator
The symbol used in an operation is called an operator.
An Operand
A variable or a value involved in an operation is called an operand.
Unary Operator
A unary operator is an operator that performs its operation on only one operand.
Binary Operator
An operator is referred to as binary if it operates on two operands.
Unary Operators: The Negative Operator -
As you may know already, in order to express any number on the left side of 0, it must be appended with a sign, namely the - symbol. Examples are -12, -448, -32706. A value accompanied by - is referred to as negative.
The - sign must be typed on the left side of the number it is used to negate.
Remember that if a number does not have a sign, it is considered positive. Therefore, whenever a number is negative, it MUST have a - sign. In the same way, if you want to change a value from positive to negative, you can just add a - sign to its left.
Here is an example that uses two variables. One has a positive value while the other has a negative value:
#include <iostream>
using namespace std;
int main()
{
int number1 = 802;
int number2 = -62;
cout << "The value of the first number is: " << number1 << "\n";
cout << "The value of the second number is: " << number2 << "\n";
}
Fundamental C++ Operators
Curly brackets are probably the most used and the most tolerant operators of C++. Fundamentally, curly brackets are used to create a section of code. As such, they are required to delimit the bodies of some items that require a delimited sections. Here is an example:
int main()
{
}
Parentheses are used to isolate a group of items that must be considered as belonging to one entity. Here is an example:
int main()
{
}
Parentheses can also be used to isolate an operation or an expression with regard to another operation or expression.
The semi-colon is used to indicate the end of a statement. Here is an example:
int main()
{
int number;
]
As we will learn, there are other uses of the semi-colon.
The comma is used to separate variables used in a group. For example, a comma can be used to delimit the names of variables that are declared with the same data type. Here is an example:
#include <iostream>
using namespace std;
int main()
{
char answer1974, hasBasement, associated;
cout << "Home Inspection" << endl;
cout << "Is the house part of a condo association?" << endl;
cout << "Type y or Y for Yes. Type n or N for No. Type d or D for I Don't Know: ";
cin >> associated;
cout << "-------------------------------------------------------------------------" << endl;
cout << "Was your house built before 1974?" << endl;
cout << "Type y or Y for Yes. Type n or N for No. Type d or D for I Don't Know: ";
cin >> answer1974;
cout << "-------------------------------------------------------------------------" << endl;
cout << "Does the house have a basement?" << endl;
cout << "Type y or Y for Yes. Type n or N for No. Type d or D for I Don't Know: ";
cin >> hasBasement;
cout << "=========================================================================" << endl;
cout << "Results of Home Inspection" << endl;
cout << "The house is a condo association: " << associated << endl;
cout << "The house was built before 1974: " << answer1974 << endl;
cout << "The house has a basement: " << hasBasement << endl;
cout << "=========================================================================";
}
Here is an example of running the programming:
Home Inspection Is the house part of a condo association? Type y or Y for Yes. Type n or N for No. Type d or D for I Don't Know: n ------------------------------------------------------------------------- Was your house built before 1974? Type y or Y for Yes. Type n or N for No. Type d or D for I Don't Know: D ------------------------------------------------------------------------- Does the house have a basement? Type y or Y for Yes. Type n or N for No. Type d or D for I Don't Know: Y ========================================================================= Results of Home Inspection The house is a condo association: n The house was built before 1974: D The house has a basement: Y ========================================================================= Press any key to close this window . . .
When you declare a variable, a memory space is reserved for it. To "put" a value in the memory space allocated to a variable, you can use the assignment operator represented as =. Based on various examples we have seen, the assignment operation is used as follows:
variable-name = value
The variable-name factor must be a valid variable name. It cannot be a value such as a numeric value or a (double-quoted) string.
A single-quote ' is used to delimit a character or symbol.
A double-quote " is used to delimit a string. The double-quote is usually combined with another. Between the combination of double-quotes, you can include an empty space, a character, a word, or a group of words, making it a string.
Introduction to Arithmetic Operators
Algebra uses a type of line to classify numbers. That line has a central point as 0 with some number to the left or below 0 and some numbers to the right or above 0. The numbers on the left side of, or below, 0 are referred to as negative while the numbers on the right or above 0 are considered positive:
A value on the right side of 0 is considered positive. To express that a number is positive, you can write a + sign on its left. Examples are +4, +228, +90335. In this case the + symbol is called a unary operator because it acts on only one operand. The positive unary operator, when used, must be positioned on the left side of its operand, never on the right side.
As a mathematical convention, when a value is positive, you don't need to express it with the + operator.
To express that a number is on the left side of, or below, 0, it must be appended with a sign, namely the - symbol. Examples are -12, -448, -32706. A value accompanied by - is referred to as negative. The - sign must be typed on the left side of the number it is used to negate.
The Addition Operations
Introduction
The addition is an operation used to add things of the same nature one to another, as many as necessary. The addition is performed using the + sign. The same sign is used in C++. Here is an example that adds two numbers:
#include <iostream>
using namespace std;
int main()
{
cout << "244 + 835 = " << 244 + 835 << endl;
}
Here is the result:
244 + 835 = 1079 Press any key to close this window . . .
You can also perform this operation on variables. You can also perform this operation using values gotten from the user.
Introduction to String Addition
You can apply the addition operation on strings the same way you would on numeric calues. You can use the + operator on strings as in "Pie" + "Chart". This would produce "PieChart". You can also apply the operator to string variables. Here is an example:
#include <iostream>
using namespace std;
int main()
{
string firstName = "Alexander";
string lastName = "Kallack";
string fullName = firstName + " " + lastName;
cout << "Full Name: ";
cout << fullName;
}
This would produce:
Full Name: Alexander Kallack Press any key to close this window . . .
Incrementing a Variable
Introduction
We are used to counting numbers such as 1, 2, 3, 4, etc. In reality, when counting such numbers, we are simply adding 1 to a number in order to get the next number in the range. The simplest technique of incrementing a value consists of adding 1 to it. You can apply this feature in computer programming. To do this, first declare a variable. Add 1 to that variable, and assign the result to the variable itself. This is illustrated in the following example:
#include <iostream>
using namespace std;
int main()
{
int value = 12;
cout << "Techniques of incrementing a value" << endl;
cout << "Value = " << value << endl;
value = value + 1;
cout << "Value = " << value;
}
This would produce:
Techniques of incrementing a value Value = 12 Value = 13 Press any key to close this window . . .
C++ provides a special operator that takes care of this operation. The operator is called the increment operator and is represented by ++. Instead of writing value = value + 1, you can write value++ and you would get the same result. The above program can be re-written as follows:
#include <iostream>
using namespace std;
int main()
{
int value = 12;
cout << "Techniques of incrementing a value" << endl;
cout << "Value = " << value << endl;
value++;
cout << "Value = " << value;
}
The ++ is a unary operator because it operates on only one variable. It is used to modify the value of the variable by adding 1 to it. Every time the Value++ is executed, the variable is incremented by one from the varlue it currenly has. Consider the following cde:
#include <iostream>
using namespace std;
int main()
{
int value = 12;
cout << "Techniques of incrementing a value" << endl;
cout << "Value = " << value << endl;
value++;
cout << "Value = " << value << endl;
value++;
cout << "Value = " << value << endl;
value++;
cout << "Value = " << value;
}
This would produce:
Techniques of incrementing a value Value = 12 Value = 13 Value = 14 Value = 15 Press any key to close this window . . .
In the above code we perform the incrementing operation before displaying its value. In som cases, you can perform the operation directly where the result is needed. Here are examples:
#include <iostream>
using namespace std;
int main()
{
int value = 12;
cout << "Techniques of incrementing a value" << endl;
cout << "Value = " << value << endl;
cout << "Value = " << value++ << endl;
cout << "Value = " << value++ << endl;
cout << "Value = " << value++;
}
This would produce:
Techniques of incrementing a value Value = 12 Value = 12 Value = 13 Value = 14 Press any key to close this window . . .
Pre and Post-Increment
When using the ++ operator, the position of the operator with regard to the variable it is modifying can be significant. To increment the value of the variable before re-using it, you should position the operator on the left of the variable. Consider the following code:
#include <iostream>
using namespace std;
int main()
{
int value = 12;
cout << "Techniques of incrementing a value" << endl;
cout << "Value = " << value << endl;
cout << "Value = " << ++value << endl;
cout << "Value = " << ++value << endl;
cout << "Value = " << ++value;
}
This would produce:
Techniques of incrementing a value Value = 12 Value = 13 Value = 14 Value = 15 Press any key to close this window . . .
When writing ++Value, the value of the variable is incremented before being called. On the other hand, if you want to first use a variable, then increment it, in other words, if you want to increment the variable after calling it, position the increment operator on the right side of the variable.
Compound Addition
Introduction
It is not unusual to add a value to a variable. All you have to do is to declare another variable that would hold the new value. Here is an example:
#include <iostream>
using namespace std;
int main()
{
double value = 12.75;
int newValue = 0;
cout << "Techniques of incrementing a variable." << endl;
cout << "======================================" << endl;
cout << "Original Value = " << value << endl;
cout << "New Value = " << newValue << endl;
cout << "--------------------------------------" << endl;
newValue = value + 5;
cout << "Original Value = " << value << endl;
cout << "New Value = " << newValue << endl;
cout << "======================================" << endl;
}
This would produce:
Techniques of incrementing a variable. ====================================== Original Value = 12.75 New Value = 0 -------------------------------------- Original Value = 12.75 New Value = 17 ====================================== Press any key to close this window . . .
The above technique requires that you use an extra variable in your application. The advantage is that each value can hold its own value although the value of the second variable depends on whatever would happen to the original or source variable. Sometimes in your program you will not need to keep the original value of the source variable. You may want to permanently modify the value that a variable is holding. In this case, you can perform the addition operation directly on the variable by adding the desired value to the variable. This operation modifies whatever value a variable is holding and does not need an additional variable.
To add a value to a variable and change the value that the variable is holding, you can combine the assignment "=" and the addition "+" operators to produce a new operator as +=. Here is an example:
#include <iostream>
using namespace std;
int main()
{
double value = 12.75;
int newValue = 0;
cout << "Techniques of incrementing a variable." << endl;
cout << "======================================" << endl;
cout << "Original Value = " << value << endl;
cout << "New Value = " << newValue << endl;
cout << "--------------------------------------" << endl;
value += 5;
cout << "Original Value = " << value << endl;
cout << "New Value = " << newValue << endl;
cout << "======================================" << endl;
}
This program would produce:
Techniques of incrementing a variable. ====================================== Original Value = 12.75 New Value = 0 -------------------------------------- Original Value = 17.75 New Value = 0 ====================================== Press any key to close this window . . .
In the above example, we incremented the variable by an integer. In the same way, you can increment a variable by a floating-point number. You can use an intermediary variable the way we started. Here is an example:
#include <iostream>
using namespace std;
int main()
{
double value = 12.75;
float newValue = 0.00;
cout << "Techniques of incrementing a variable." << endl;
cout << "======================================" << endl;
cout << "Original Value = " << value << endl;
cout << "New Value = " << newValue << endl;
cout << "--------------------------------------" << endl;
newValue = value + 16.38;
cout << "Original Value = " << value << endl;
cout << "New Value = " << newValue << endl;
cout << "======================================" << endl;
}
This program would produce:
Techniques of incrementing a variable. ====================================== Original Value = 12.75 New Value = 0 -------------------------------------- Original Value = 12.75 New Value = 29.13 ====================================== Press any key to close this window . . .
Or you can perform the operation directly on a variable that needs the increment. Here is an example:
#include <iostream>
using namespace std;
int main()
{
double value = 12.75;
float newValue = 0.00;
cout << "Techniques of incrementing a variable." << endl;
cout << "======================================" << endl;
cout << "Original Value = " << value << endl;
cout << "New Value = " << newValue << endl;
cout << "--------------------------------------" << endl;
value += 16.38;
cout << "Original Value = " << value << endl;
cout << "New Value = " << newValue << endl;
cout << "======================================" << endl;
}
This would produce:
Techniques of incrementing a variable. ====================================== Original Value = 12.75 New Value = 0 -------------------------------------- Original Value = 29.13 New Value = 0 ====================================== Press any key to close this window . . .
Compound Addition and Strings
Imagine you want to combine two strings to get a new string. In the above examples, we performed the compound addition on numbers. You can also perform this operation on strings. As seen with numbers, you can use an intermediary string variable. Here are examples:
#include <iostream>
using namespace std;
int main()
{
string firstName = "Paul";
string fullName = "";
cout << "Techniques of incrementing a variable." << endl;
cout << "======================================" << endl;
cout << "First Name = " << firstName << endl;
cout << "Full Name = " << fullName << endl;
cout << "--------------------------------------" << endl;
fullName = firstName + " Motto";
cout << "First Name = " << firstName << endl;
cout << "Full Name = " << fullName << endl;
cout << "======================================" << endl;
}
This would produce:
Techniques of incrementing a variable. ====================================== First Name = Paul Full Name = -------------------------------------- First Name = Paul Full Name = Paul Motto ====================================== Press any key to close this window . . .
Instead of, or besides, the regular addition, you can use the compound addition, +=, practically the same way it is used for numbers. Here is an example:
#include <iostream>
using namespace std;
int main()
{
string fullName = "Paul";
string someName = "";
cout << "Techniques of incrementing a variable." << endl;
cout << "======================================" << endl;
cout << "First Name = " << fullName << endl;
cout << "Some Name = " << someName << endl;
cout << "--------------------------------------" << endl;
fullName += " Motto";
cout << "Full Name = " << fullName << endl;
cout << "Some Name = " << someName << endl;
cout << "======================================" << endl;
}
This would produce:
Techniques of incrementing a variable. ====================================== First Name = Paul Some Name = -------------------------------------- Full Name = Paul Motto Some Name = ====================================== Press any key to close this window . . .
Introduction
The multiplication allows adding one value to itself a certain number of times, set by a second value. As an example, instead of adding a value to itself in this manner: A + A + A + A, since the variable A is repeated over and over again, you could simply find out the number of times A is added to itself, then multiply A by that number which, is this case, is 4. This would mean adding A to itself 4 times, and you would get the same result.
When it comes to programming syntax, the rules we learned with the addition operation also apply to the multiplication. Consider the following example:
#include <iostream>
using namespace std;
int main()
{
double value1 = 224.58, value2 = 1548.26;
double result = value1 * value2;
cout << value1 << " * " << value2 << " = " << result << endl;
}
This would produce:
224.58 * 1548.26 = 347708.2308 Press any key to close this window . . .
Compound Multiplication
You can multiply a value by a variable and assign the result to the same variable. Here is an example:
#include <iostream>
using namespace std;
int main()
{
float value = 36.73;
int newValue = 0;
cout << "Original Value = " << value << endl;
cout << "New Value = " << newValue << endl;
cout << "-----------------------" << endl;
newValue = value * 5;
cout << "Original Value = " << value << endl;
cout << "New Value = " << newValue << endl;
cout << "=======================" << endl;
}
This would produce:
Original Value = 36.73 New Value = 0 ----------------------- Original Value = 36.73 New Value = 183 ======================= Press any key to close this window . . .
To make this operation easy, the C++ language supports the compound multiplication assignment operator represented as *=. To use it, use the *= operator and assign the desired value to the variable. Here is an example:
#include <iostream>
using namespace std;
int main()
{
float value = 36.73;
int newValue = 0;
cout << "Original Value = " << value << endl;
cout << "New Value = " << newValue << endl;
cout << "-----------------------" << endl;
value *= 5;
cout << "Original Value = " << value << endl;
cout << "New Value = " << newValue << endl;
cout << "=======================" << endl;
}
This would produce:
Original Value = 36.73 New Value = 0 ----------------------- Original Value = 183.65 New Value = 0 ======================= Press any key to close this window . . .
Introduction
The subtraction operation is used to take out or subtract a value from another value. It is essentially the opposite of the addition. The subtraction is performed with the - sign. Here is an example:
#include <iostream>
using namespace std;
int main()
{
int value1 = 82468, value2 = 54826;
int result = value1 - value2;
cout << value1 << " - " << value2 << " = " << result << endl;
}
This would produce:
82468 - 54826 = 27642 Press any key to close this window . . .
In the above example, we used integers. In the same way, we can perform a subtraction on a floating-point an integer or on floating-point numbers.
Decrementing a Variable
When counting numbers backward, such as 8, 7, 6, 5, etc, we are in fact subtracting 1 from a value in order to get the lesser value. This operation is referred to as decrementing a value. This operation works as if a value is decremented by 1. Here is an example:
#include <iostream>
using namespace std;
int main()
{
double value = 325;
int newValue = 0;
cout << "Techniques of decrementing a variable." << endl;
cout << "======================================" << endl;
cout << "Original Value = " << value << endl;
cout << "New Value = " << newValue << endl;
cout << "--------------------------------------" << endl;
newValue = value + 1;
cout << "Original Value = " << value << endl;
cout << "New Value = " << newValue << endl;
cout << "======================================" << endl;
}
This would produce:
Techniques of decrementing a variable. ====================================== Original Value = 325 New Value = 0 -------------------------------------- Original Value = 325 New Value = 324 ====================================== Press any key to close this window . . .
As done to increment, C++ provides a quicker way of subtracting 1 from a value. This is done using the decrement operator, that is --. To use the decrement operator, type - on the left or the right side of the variable when this operation is desired. Using the decrement operator, the above program could be written:
#include <iostream>
using namespace std;
int main()
{
double value = 325;
int newValue = 0;
cout << "Techniques of decrementing a variable." << endl;
cout << "======================================" << endl;
cout << "Original Value = " << value << endl;
cout << "New Value = " << newValue << endl;
cout << "--------------------------------------" << endl;
value--;
cout << "Original Value = " << value << endl;
cout << "New Value = " << newValue << endl;
cout << "======================================" << endl;
}
This would produce:
Techniques of decrementing a variable. ====================================== Original Value = 325 New Value = 0 -------------------------------------- Original Value = 324 New Value = 0 ====================================== Press any key to close this window . . .
Pre-Decrementing a Value
In some cased, the position of the -- operator can be important. If you want to decrement the variable before calling it, position the decrement operator on the left side of the operand. This is illustrated in the following program:
#include <iostream>
using namespace std;
int main()
{
int value = 12;
cout << "Techniques of decrementing a value" << endl;
cout << "Value = " << value << endl;
cout << "Value = " << --value << endl;
cout << "Value = " << --value << endl;
cout << "Value = " << --value;
}
This would produce:
Techniques of decrementing a value Value = 12 Value = 11 Value = 10 Value = 9 Press any key to close this window . . .
If you plan to decrement a variable only after it has been accessed, position the operator on the right side of the variable. Here is an example:
#include <iostream>
using namespace std;
int main()
{
int value = 12;
cout << "Techniques of decrementing a value" << endl;
cout << "Value = " << value << endl;
cout << "Value = " << value-- << endl;
cout << "Value = " << value-- << endl;
cout << "Value = " << value--;
}
This would produce:
Techniques of decrementing a value Value = 12 Value = 12 Value = 11 Value = 10 Press any key to close this window . . .
Compound Subtraction
You may want to subtract a value from a variable. Here is an example:
#include <iostream>
using namespace std;
int main()
{
int value = 328;
int newValue = 0;
cout << "Techniques of decrementing a variable." << endl;
cout << "======================================" << endl;
cout << "Original Value = " << value << endl;
cout << "New Value = " << newValue << endl;
cout << "--------------------------------------" << endl;
newValue = value - 5;
cout << "Original Value = " << value << endl;
cout << "New Value = " << newValue << endl;
cout << "======================================" << endl;
}
This would produce:
Techniques of decrementing a variable. ====================================== Original Value = 328 New Value = 0 -------------------------------------- Original Value = 328 New Value = 323 ====================================== Press any key to close this window . . .
To decrement a value from a variable, use the -= operator. Here is an example:
#include <iostream>
using namespace std;
int main()
{
int value = 328;
int newValue = 0;
cout << "Techniques of decrementing a variable." << endl;
cout << "======================================" << endl;
cout << "Original Value = " << value << endl;
cout << "New Value = " << newValue << endl;
cout << "--------------------------------------" << endl;
value -= 5;
cout << "Original Value = " << value << endl;
cout << "New Value = " << newValue << endl;
cout << "======================================" << endl;
}
This would produce:
Techniques of decrementing a variable. ====================================== Original Value = 328 New Value = 0 -------------------------------------- Original Value = 323 New Value = 0 ====================================== Press any key to close this window . . .
Introduction
Dividing an item means cutting it in pieces or fractions of a set value. Therefore, the division is used to get the fraction of one number in terms of another. The division is performed with the forward slash /. Normally, you should perform an operation mostly on floating-point numbers. Here is an example:
#include <iostream>
using namespace std;
int main()
{
float value1 = 1548.26, value2 = 224.58;
float result = value1 / value2;
cout << value1 << " / " << value2 << " = " << result << endl;
}
This would produce:
1548.26 / 224.58 = 6.89402 Press any key to close this window . . .
You can also perform a division on a floating-point number and an integer. In that case, the result would be a decimal number. Here is an example:
#include <iostream>
using namespace std;
int main()
{
float value1 = 315866.2639, value2 = 17;
float result = value1 / value2;
cout << value1 << " / " << value2 << " = " << result << endl;
}
This would produce:
315866 / 17 = 18580.4 Press any key to close this window . . .
You can also perform a division on a natural numbers. If you do, the result would be a natural number. Consider the following example:
#include <iostream>
using namespace std;
int main()
{
int value1 = 82468, value2 = 52;
int result = value1 / value2;
cout << value1 << " / " << value2 << " = " << result << endl;
}
This would produce:
82468 / 52 = 1585 Press any key to close this window . . .
When performing the division, be aware of its many rules. Never divide by zero (0). Make sure that you know the relationship(s) between the numbers involved in the operation.
Compound Division
Remember that you can add, subtract, or multiply a value to a variable and assign the result to the variable itself. You can also perform this operation using the division. Here is an example:
#include <iostream>
using namespace std;
int main()
{
float value = 3628.73;
int newValue = 0;
cout << "Original Value = " << value << endl;
cout << "New Value = " << newValue << endl;
cout << "--------------------------------------" << endl;
newValue = value / 5;
cout << "Original Value = " << value << endl;
cout << "New Value = " << newValue << endl;
cout << "======================================" << endl;
}
This would produce:
Original Value = 3628.73 New Value = 0 -------------------------------------- Original Value = 3628.73 New Value = 725 ====================================== Press any key to close this window . . .
To perform this operation faster, the C++ language provides the /= operator. Here is an example of using it:
#include <iostream>
using namespace std;
int main()
{
float value = 3628.73;
int newValue = 0;
cout << "Original Value = " << value << endl;
cout << "New Value = " << newValue << endl;
cout << "--------------------------------------" << endl;
value /= 5;
cout << "Original Value = " << value << endl;
cout << "New Value = " << newValue << endl;
cout << "======================================" << endl;
}
This would produce:
Original Value = 3628.73 New Value = 0 -------------------------------------- Original Value = 725.746 New Value = 0 ====================================== Press any key to close this window . . .
In the above operations, we performed the divisions on an integer. In the same way, the denominator can be a floating-point number.
Introduction
The division program gives a result of a number with decimal values if you provide an odd number (like 147), which is fine in some circumstances. Sometimes you will want to get the value remaining after a division renders a natural result. The remainder operation is performed with the percent sign (%). Here is an example:
#include <iostream>
using namespace std;
int main()
{
int value = 9628;
int newValue = 0;
cout << "Original Value = " << value << endl;
cout << "New Value = " << newValue << endl;
cout << "--------------------------------------" << endl;
newValue = value % 73;
cout << "Original Value = " << value << endl;
cout << "New Value = " << newValue << endl;
cout << "======================================" << endl;
}
This would produce:
Original Value = 9628 New Value = 0 -------------------------------------- Original Value = 9628 New Value = 65 ====================================== Press any key to close this window . . .
The Compound Remainder
As seen with the other arithmetic operators, you can find the remainder of a variable and assign the result to the variable itself. Here is an example:
#include <iostream>
using namespace std;
int main()
{
int value = 9628;
cout << "Value = " << value << endl;
cout << "-----------------" << endl;
value = value % 73;
cout << "Value = " << value << endl;
cout << "=================" << endl;
}
This would produce:
Value = 9628 ----------------- Value = 65 ================= Press any key to close this window . . .
To support a faster version of this operation, the C++ language provides the compound remainder operator represented as %=. To use it, assign its value to the variable. Here is an example:
#include <iostream>
using namespace std;
int main()
{
int value = 9628;
cout << "Value = " << value << endl;
cout << "-----------------" << endl;
value %= 73;
cout << "Value = " << value << endl;
cout << "=================" << endl;
}
This code produces the same result as the previous one.
|
|
|||
| Previous | Copyright © 2002-2026, FunctionX | Wednesday 24 September 2025, 14:13 | Next |
|
|
|||