Operator in C ++

Boolean operators in C ++

The following table specifies all logical operators supported by the C language.

Suppose variable A has value 1 and variable B has value 0:

Bit comparison operator in C ++

The bit comparison operator works on bit units, calculates bitwise comparison expressions. The following table is about &, |, and ^ as follows:

Suppose if A = 60; and B = 13; then in binary format they will be as follows:

A = 0011 1100

B = 0000 1101

-----------------

A&B = 0000 1100

A | B = 0011 1101

A ^ B = 0011 0001

~ A = 1100 0011

Bit comparison operators supported by the C ++ language are listed in the table below. The price we use has variable A having the value 60 and variable B having the value 13, we have:

The assignment operator in C ++

Here are the assignment operators supported by the C ++ language:

Mixed operators in C ++

Here are some important mixed operators supported by the C ++ language.

The sizeof operator in C ++

sizeof is a keyword in C ++, but it is a compile-time operator that determines the size, by byte value, of a variable or data type.

The sizeof operator can be used to get the size of the class, structure, union and any other self-defined data types (user-defined) in C ++.

The syntax for using the sizeof operator in C ++ is as follows:

 sizeof (travel guide) 

Here, data type is a data type consisting of class, structure, union and any other self-defined data types (user-defined) in C ++.

Try the following example to understand how to use the sizeof operator in C ++. Copy and paste the following program in the test.cpp file, then compile and run the program.

 chứa 
 using namespace std; 

 int main () 
 { 
 cout << "Kich co char:" << sizeof (char) << endl; 
 cout << "Kich has int:" << sizeof (int) << endl; 
 cout << "Short int:" << sizeof (short int) << endl; 
 cout << "Kich co int:" << sizeof (long int) << endl; 
 cout << "Kich has a float:" << sizeof (float) << endl; 
 cout << "Kich has double:" << sizeof (double) << endl; 
 cout << "Curious wchar_t:" << sizeof (wchar_t) << endl; 
 return 0; 
 } 

Running the above C ++ program will produce the following results:

Operator in C ++ Picture 3

Conditional operator? : in C ++

Syntax of conditional operator? : in C ++ is:

 bieu_thuc_1? bieu_thuc_2: bieu_thuc_3; 

Here, bieu_thuc_1, bieu_thuc_2 and bieu_thuc_3 are expressions. Notice the use and position of the colon. Value of an expression? The decision is as follows: bieu_thuc_1 is estimated. If it is true, then bieu_thuc_2 is evaluated and becomes the value of the entire expression. If bieu_thuc_1 is false, then bieu_thuc_3 is evaluated and its value becomes the value of the expression?

Expression ? is treated as a trin operator because it requires three operands and can be used to replace the if-else statement, with the following form:

 if (dieu_kien) { 
 var = X; 
 } else { 
 var = Y; 
 } 
 You consider the following code: 

 if (y <10) { 
 var = 30; 
 } else { 
 var = 40; 
 } 

The above code can be rewritten like this:

 var = (y <10)? 30: 40; 

Here, x is assigned a value of 30 if y is less than 10 and is assigned 40 if not less than 10. You can try the following example:

 #include 
 using namespace std; 

 int main () 
 { 
 // How to open the package: 
 int x, y = 10; 

 x = (y <10)? 30: 40; 

 cout << "Family tri x la:" << x << endl; 

 return 0; 
 } 

When the above code is compiled and executed, it gives the following result:

 Family: 40 

The comma operator in C ++

The purpose of the comma operator in C ++ is to string some expressions together. The value of an expression list distinguished by commas is the value of the last right expression. Basically, the effect of commas is to make a sequence of operations to be performed.

The values ​​of other expressions will be removed. That is, the last right expression will become the value of the entire expression distinguished by a comma. For example:

 var = (biendem = 19, incr = 10, biendem + 1); 

Here, first assign biendem value 19, assign increment value 10, then add 1 to biendem, and finally, assign var the value of the rightmost expression, the expression biendem + 1, is 20. Parentheses are necessary because the comma operator has a lower priority than the assignment operator.

To see the effect of the comma operator, try running the following example:

 #include 
 using namespace std; 

 int main () 
 { 
 int i, j; 

 j = 10; 
 i = (j ++, j + 100, 999 + j); 

 cout << i; 

 return 0; 
 } 

When the above code is compiled and executed, it gives the following result:

 1010 

The procedure in which the value of i is estimated is: j starts with value 0. Then j is increased to 11. Then j is added to 100. Finally, j (still contains 11) is added to 999 , which will result in 1010.

Member operator (. And ->) in C ++

Dot (.) And arrow operator (->) are used to reference individual members of the class, struct and union structures in C ++.

The dot operator is applied to the actual object. The arrow operator is used with a pointer to an object. For example, consider the following structure:

 struct sinhvien { 
 char ten [16]; 
 int diemthi; 
 } sv; 

The dot (.) Operator in C ++

To assign a "wild" value to the ten member of the sinhvien object, write:

 strcpy (sinhvien.ten, "hoang"); 

Arrow operator (->) in C ++

If p_sv is a pointer to an object of type sinhvien, then to assign a "wild" value to the ten member of the sinhvien object, write:

 strcpy (p_sv-> ten, "wild"); 

It can be said simply: To access members of a structure, use the dot operator in C ++. To access the members of a structure through a pointer, use the arrow operator.

Casting in C ++

The cast operator (a cast) in C ++ is a special operator that makes this type of data transform into another data type. The cast operator is a single-operator and has the same priority as any other unary operator in C ++.

The frequently used syntax of the cast operator in C ++ is:

 (kieu_du_lieu) bieu_thuc 

Here, kieu_du_lieu is the type of data you want. Here are some cast operators that are supported by C ++:

const_cast (bieu_thuc) : The const_cast operator is used to override const and / or volatile. The data type you want must be the same as the source data type except for the modification of the const or volatile properties in a cast. This casting type manipulates the const attribute of the transmitted object: either set or removed.

dynamic_cast (bieu_thuc) : The dynamic_cast operator in C ++ performs a casting at runtime that verifies the validity of cast. If the cast cannot be created, this cast fails and the estimated expression is null. A dynamic_cast operator performs castings on polymorphic types and can force an A * pointer to a B * pointer only if the object being pointed is actually an B object.

reinterpret_cast (bieu_thuc) : The reinterpret_cast operator in C ++ changes a pointer to any other pointer type. It also allows casting from pointers to an integer type and vice versa.

static_cast (bieu_thuc) : The static_cast operator in C ++ performs a non-polymorphic cast. For example, it can be used to cast a base class pointer to a legacy class pointer.

All of these cast operators will be used while working with classes and objects. Now, try the following example to understand a simple cast operator in C ++. Copy and paste the following C ++ program in the test.cpp file, then compile and run the program:

 chứa 
 using namespace std; 

 main () 
 { 
 double a = 15.65653; 
 float b = 9.02; 
 int c; 

 c = (int) a; 
 cout << "Dong 1: Family member (int) a la:" << c << endl; 

 c = (int) b; 
 cout << "Dong 1: Family (int) b la:" << c << endl; 

 return 0; 
 } 

Running the above C ++ program will produce the following results:

Operator in C ++ Picture 4

The cursor operator in C ++

C ++ provides two pointer operators: the & operator (address of operator) and the * operator (indirection operator).

A pointer is a variable that contains the address of another variable or you can say that a variable containing the address of another variable is treated as a pointer to another variable. A variable can be any data type, including object, structure, or pointer itself.

Operator . (dot) and the -> (arrow) operator are used to refer to individual members of the class, structure, and union.

Operator & in C ++

The & operator is a unary operator in C ++ that returns the memory address of its operand. For example, if var is an integer variable, & var is its address. This operator has the same precedence and right-to-left order as other unary operators in C ++.

You should read the & operator as "address of", meaning that & var will be read as "var's address".

Operator * in C ++

The second pointer operator is the * operator in C ++, and it is an addition to the & operator. This is a unary operator that returns the value of the variable located at the address specified by its operand.

The following is a program that illustrates two types of pointer operators in C ++:

 #include 

 using namespace std; 

 int main () 
 { 
 int var; 
 int * ptr; 
 int val; 

 var = 3000; 

 // divide the variable bien var 
 ptr = & var; 

 // Lay gia tri ptr 
 val = * ptr; 
 cout << "The list of var la:" << var << endl; 
 cout << "Family knowledge of ptr la:" << ptr << endl; 
 cout << "Family tri val la:" << val << endl; 

 return 0; 
 } 

 Running the above C ++ program will produce the following results: 

Operator in C ++ Picture 5

Priority order operator in C ++

The precedence of operator in C ++ determines how the expression is calculated. For example, the multiplication operator takes precedence over the addition operator, and it is done first.

For example, x = 7 + 3 * 2; Here, x is assigned a value of 13, not 20 because the * operator has a higher priority than the + operator, so first it performs multiplication 3 * 2 and then adds 7.

The following table lists the priority order of operators. Operators with the highest priority appear at the top of the table, and the operators with the lowest priority are at the bottom of the table. In an expression, the highest priority operators are first calculated.

According to Tutorialspoint

Last lesson: Storage Class in C / C ++

Next article: Loop in C ++