Operadores de C ++

operadores son símbolos que tengan uno o más operandos o expresiones y realizar cálculos aritméticos o lógicos.
C ++ soporta todos los operadores de C introduce, C ++ algunos nuevos operadores dados de la siguiente manera:

Símbolos Nombre
> Extracción operador.
:: operador de resolución de alcance.
:: * puntero a miembro declarador.
-> * operador puntero a miembro.
. * puntero a miembro del operador.
nueva operador de asignación de memoria dinámica.
de borrado de memoria suelte.

Operador de Resolución (SRO) ::

:: (resolución de alcance) operador se utiliza para calificar los nombres ocultos por lo que todavía puede usarlos.
:: (SRO) se pueden utilizar dos tipos:

  1. Usted puede utilizar el operador unario alcance if un ámbito de espacio de nombre o nombre de ámbito mundial está oculta por una declaración explícita del mismo nombre en un bloque o una clase de .
  2. También puede utilizar el operador ámbito de clase para calificar los nombres de clase o nombres de los miembros de clase. If un nombre de miembro de la clase se oculta, se puede usar al clasificarse con su nombre de clase y el operador ámbito de clase.

    Use of unary SRO:
:: variable_name;
Use as class scope (to access class member):
class_name :: class_member;

// Program to illustrate :: (SRO operator)
#include <iostream.h>
int var=100; // Global variable
int main()
{
int var=200;
cout<<"value of var (local) : "<<var<<endl;
cout<<"value of var (Global): "<<::var<<endl;
::var=::var+20; // updating global value
var=var+20; // updating local value
cout<<"nAFTER UPDATING VALUESn";
cout<<"value of var (local) : "<<var<<endl;
cout<<"value of var (Global): "<<::var<<endl;
return 0;
}

salida

value of var (local) : 200
value of var (Global): 100
AFTER UPDATING VALUES
value of var (local) : 220
value of var (Global): 120

Programa para ilustrar :: (operador SRO) con la clase

#include <iostream.h>
class sample{
public:
static int count;
};
int sample::count =100;
int main(){
cout<<"Value is = "<<sample::count<<endl;
sample::count+=1;
cout<<"AFTER UPDATING..........n";
cout<<"Value is = "<<sample::count<<endl;
return 0;
}

salida

Value is = 100
AFTER UPDATING..........
Value is = 101

miembro operador de eliminación de referencias

permisos de C ++ para acceder a las funciones miembro de clase a través de puntero, para conseguir esta funcionalidad (acceso a miembro de la clase a través de un puntero), C ++ proporciona el conjunto de estos tres operadores para declarar y acceso.

-puntero a miembro declarador [ :: * ]:

se utiliza para declarar un puntero de función miembro.
Para acceder a la función de miembro de la clase utilizando el puntero, debe declarar el puntero de esa función.

    Return_Type (Class_Name::* pointer_name) (Argument_List)= & class_name::fun_name;

operador-Indicador-a miembro [ * .]:

se utiliza para la función de elemento de acceso thorugh puntero, (objeto de clase if no es un puntero)

puntero a miembro operador [-> *]:

se utiliza para la función de miembro de acceso thorugh puntero, (objeto de clase if es un puntero)

    (Object_Name .*Pointer_Fun_Name)([Argument_List]);
(Pointer_Object_Name ->*Pointer_Fun_Name)([Argument_List]);

#include <iostream.h>
class Sample
{
    private:
int a;
public :
Sample(int a) //constructor
{
this->a=a;
}
int fun(void)
{
cout<<"nBody of fun (class Sample), value of a= "<< a << endl;
return 0;
}
};
int main()
{
Sample Obj(100),*PObj;
PObj=&Obj;
// declaration of pointer to member function..
int (Sample::*ptrFun)(void);
// initialization of pointer to member function
ptrFun=&Sample::fun;
// access using simple object
(Obj.*ptrFun)();
// access using pointer object
(PObj->*ptrFun)();
return 0;
}

salida

Body of fun (class Sample), value of a= 100
Body of fun (class Sample), value of a= 100

operadores new y delete

nueva se utiliza para asignar memoria para una variable, objeto, matriz, matriz de objetos .. etc en tiempo de ejecución. “Para declarar la memoria en tiempo de ejecución se conoce como asignación de memoria dinámica.” usamos la memoria por este método (asignación dinámica) cuando no se sabe de antemano cómo se necesita mucho espacio en la memoria.

desde “estos operadores manipular la memoria en la tienda libre, por lo que también se conocen como operadores de tiendas libres.

el nuevo operador se puede utilizar para crear objetos de cualquier tipo, se necesita la siguiente forma general:

    pointer_variable = new data_type;

Aquí, pointer_variable es una variable que almacenan la dirección inicial de la asignación de espacio de memoria

// Program to illustrate new ..
#include <iostream.h>
int main(){
int *age=new int;
char *gender=new char;
*age=0; // assigning default value (not necessary)
*gender='M'; // assigning default value (not necessary)
// taking input through keyboard
cout<<"Enter your age ? :";
cin>> (*age);
cout<<"AGE IS : "<< *age <<",GENDER IS : "<< *gender << endl;
return 0;
}

salida

Enter your age ? :23
AGE IS : 23,GENDER IS : M

eliminar operador:.

borrar operador se utiliza para desasigna la memoria asignada dinámicamente.

Desde la necesidad de memoria dinámica se limita generalmente a momentos específicos dentro de un programa, una vez que ya no es necesario que debe ser liberado para que la memoria vuelva a estar disponible para otras solicitudes de memoria dinámica. Este es el propósito de la junta perator eliminar.

delete toma la siguiente forma general:

    1. delete pointer_variable;
2. delete []pointer_variable;

La primera expresión se debe utilizar para la memoria de borrado asignado para un solo elemento, y el segundo para la memoria asignada para las matrices de elementos.

// Program to declare dynamic array of integers...
#include <iostream.h>
int main(){
int *array; // declaration
int max,i;
cout<<"Enter total number of elements :";
cin>>max;
// declare memory @ run time to max element...
array=new int[max];
// read values
cout<<"Enter array elements:n";
for(i=0;i< max;i++){
cout<<"Element "<< i+1 <<": ";
cin>> array[i];
}
cout<<"Elements are : ";
for(i=0;i< max;i++){
cout<< array[i] <<"t";
}
// release dynamically allocated space
delete []array;
cout<< endl;
return 0;
}

salida

Enter total number of elements :5
Enter array elements:
Element 1: 111
Element 2: 222
Element 3: 333
Element 4: 444
Element 5: 555
Elements are : 111 222 333 444 555

Nota ******* después de liberar la memoria, pointer_variable no destruye, solamente el bloque de memoria asignada destruido.

considerar el siguiente código:

delete []array;
cout<<"nElements are (after releasing memory):n";
for(i=0;i< max;i++){
cout<< array[i] <<"t";
}

salida

Enter total number of elements :5
Enter array elements:
Element 1: 111
Element 2: 222
Element 3: 333
Element 4: 444
Element 5: 555
Elements are : 111 222 333 444 555
Elements are (after releasing memory):
-572662307 -572662307 -572662307 -572662307 -572662307

eliminar Operador de 2-D Matriz:

Podemos declarar una matriz 2-D utilizando nuevo operador.
que toma la siguiente forma general:

pointer_variable = new-tipo de datos [MAX_ROW * max_col];

aquí MAX_ROW es el número máximo de filas y max_col es el número máximo de cols.

Tenga en cuenta que la expresión anterior de X [i] [j] ha sido reemplazado por X [i * c + j] .

donde c representa el número máximo de columnas en la matriz 2-D X.

//Declare 2-D array using new operator
#include <iostream.h>
int main(){
int *arr;
int rows,cols,i,j;
cout<<"Enter rows ?:";
cin>>rows;
cout<<"Enter cols ?:";
cin>>cols;
// declare 2-D array
arr=new int[rows*cols];
// read value
cout<<"Enter elements ..n";
for(i=0;i< rows;i++){
for(j=0;j< cols;j++){
cout<<"Enter value ? :";
cin>>arr[i*cols+j];
}
}
// print in matrix format
cout<<"Entered elements are :n";
for(i=0;i< rows;i++){
for(j=0;j< cols;j++){
cout<< arr[i*cols+j]<<"t";
}
cout<< endl;
}
return 0;
}


Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *