sizeof () del operador en C / C ++

C / C ++ sizeof () Operador : En este tutorial, vamos a discutir los detalles sobre el operador sizeof () en C / C ++ a partir de su uso, ejemplos a aplicaciones.

Definición de sizeof () operador

sizeof operador es un operador unitario que toma un único operando y el operando puede ser de tipo de datos, las variables, los objetos, expresiones, y cualquier cosa que tenga un tamaño , es decir, que adquiere una cierta memoria. Nos veremos en el ejemplo de uso de la sección operador sizeof , que es posible que tenga que nunca a pesar de.

detalles de sizeof () operador

Tipo de Operador Unario
Operandos tipos de datos, las expresiones, las variables, los objetos
La sobrecarga no se puede sobrecargar
Precedencia Igual que otros operadores unitarios, después de que los operadores de sufijo
asociatividad de derecha a izquierda
uso Tamaño de la cantidad de memoria asignada return en bytes

sizeof () del operador en los tipos de datos

Como sabemos las diferentes versiones de los compiladores le asignan las diferentes cantidades de memoria para los tipos de datos. Al igual que en las versiones anteriores, se asignaron números enteros de 2 bytes de memoria, mientras que en las versiones más recientes y que rsquo; s 4 bytes. Podemos comprobar fácilmente que mediante el operador sizeof .

#include <stdio.h>
int main()
{
printf("size of integer data type is: %lun", sizeof(int));
printf("size of float data type is: %lun", sizeof(float));
printf("size of double data type is: %lun", sizeof(double));
printf("size of character data type is: %lun", sizeof(char));
return 0;
}

Salida:

size of integer data type is: 4
size of float data type is: 4
size of double data type is: 8
size of character data type is: 1

sizeof operador de variables, expresiones

también podemos utilizar el operador sizeof para encontrar el tamaño de cualquier variable, expresiones. Los espectáculos del programa por debajo de cómo utilizar el operador sizeof para encontrar el tamaño de cualquier variable.

#include <stdio.h>
int main()
{
int a;
char b;
float c;
double d;
long e;
long long f;
long long int g;
printf("sizeof a which is of type int is: %lun", sizeof(a));
printf("sizeof a which is of type char is: %lun", sizeof(b));
printf("sizeof a which is of type float is: %lun", sizeof(c));
printf("sizeof a which is of type double is: %lun", sizeof(d));
printf("sizeof a which is of type long is: %lun", sizeof(e));
printf("sizeof a which is of type long long is: %lun", sizeof(f));
printf("sizeof a which is of type long long int is: %lun", sizeof(g));
return 0;
}

Salida:

sizeof a which is of type int is: 4
sizeof a which is of type char is: 1
sizeof a which is of type float is: 4
sizeof a which is of type double is: 8
sizeof a which is of type long is: 8
sizeof a which is of type long long is: 8
sizeof a which is of type long long int is: 8

La siguiente muestra de programa cómo utilizar el operador sizeof para encontrar el tamaño de cualquier expresión,

#include <stdio.h>
int main()
{
int a = 9;
char b = 'a';
float c = 8.7;
double d = 0.99;
long e = 12;
long long f = 13;
long long int g = 16;
printf("sizeof a+c which is of type int+float is: %lun", sizeof(a + c));
printf("sizeof c+d which is of type float+doyble is: %lun", sizeof(c + d));
printf("sizeof a+e which is of type int+long is: %lun", sizeof(a + e));
printf("sizeof a+c+f which is of type int+float+long long is: %lun", sizeof(a + c + f));
return 0;
}

Salida:

sizeof a+c which is of type int+float is: 4
sizeof c+d which is of type float+doyble is: 8
sizeof a+e which is of type int+long is: 8
sizeof a+c+f which is of type int+float+long long is: 4

If se observa el anterior programación, el operador sizeof le informa sobre el concepto de tipo de datos ampliación . ¿Has observado cuando se añade un int con long e, el resultante tiene el tamaño de 8 bytes, que es el mismo que el tamaño de long. Así que eso significa, sin embargo usted tiene int como un operando, el resultado tendrá como tipo de datos long debido al concepto de tipo de datos ensanchamiento . Esto también es similar al añadir float tipo C con double tipo 8, otra vez vimos una instancia de tipo de datos ampliación . operadores sizeof ayudan a validar el concepto también.

sizeof operario encuentre sizeof un objeto

Para saber qué tamaño de un objeto es, podemos utilizar el operador sizeof fácilmente. Normalmente, el tamaño de un objeto es la suma de sus miembros de datos constituyente. Está garantizado que el tamaño de un objeto nunca será menor que eso, pero lo que hace es que el compilador compilador añade relleno entre los miembros de datos para garantizar los requisitos de alineación de la plataforma. Eso es uno puede comprobar fácilmente que mediante el uso del operador sizeof.

continuación se muestra un ejemplo en el que el objeto tiene tres miembros de datos, una cadena y dos enteros. Por lo tanto, el tamaño debe haber sido 8 (depende del compilador, se puede comprobar el tamaño de cadena usando el operador sizeof) + 4 + 4 pero es encontrado por el operador 24 sizeof y eso es debido a la adición del compilador espacio relleno.

#include <iostream>
using namespace std;
class student {
public:
int roll;
string name;
int marks;
};
int main()
{
student st;
st.name = "xyz";
st.roll = 1;
st.marks = 80;
printf("sizeof student object st is: %lun", sizeof(st));
return 0;
}

Salida:

sizeof student object st is: 24

sizeof operario encuentre tamaño de la matriz

Podemos utilizar el operador sizeof encontrar tamaño de la matriz. El tamaño de la matriz será matriz de longitud * sizeof (tipo de datos).

#include <iostream>
using namespace std;
int main()
{
int marks[20];
cout << "sizeof the array marks is: " << sizeof(marks) << endl;
return 0;
}

Salida:

sizeof the array marks is: 80

sizeof operador también ayuda a encontrar la longitud de gama muy fácilmente. La longitud de la matriz será,

length of array= sizeof(array)/sizeof(datatype)

continuación se muestra un ejemplo:

#include <iostream>
using namespace std;
int main()
{
int arr[] = { 12, 76, 45, 10, 5, 1, 6, 17, 89 };
cout << "length the array arr is: " << sizeof(arr) / sizeof(int) << endl;
return 0;
}

de salida:

length the array arr is: 9

asignación de memoria dinámica utilizando operador sizeof

continuación es el ejemplo en el que dinámicamente asignar memoria utilizando la función malloc (), donde sizeof ayuda a definir el tamaño de un solo elemento,

#include <stdio.h>
#include <stdlib.h>
int main()
{
int* arr = (int*) malloc(sizeof(int) * 20);
for (int i = 0; i < 10; i++)
arr[i] = i;
if (arr == NULL)
printf("Memory couldn't be allocatedn");
else
printf("Memory got allocatedn");
return 0;
}

salida:

Memory got allocated

Juguemos con el operador sizeof más y esto puede ser grave engaña cerebros.

Adivina la salida de los siguientes códigos.

Código 1:

#include <bits/stdc++.h>
using namespace std;
int main()
{
queue<int> q;
stack<int> st;
vector<int> a;
cout << "size of the queue q is:" << sizeof(q) << endl;
cout << "size of the stack st is:" << sizeof(st) << endl;
cout << "size of the vector a is:" << sizeof(a) << endl;
return 0;
}

¿Adivinaste todas las salidas a ser 0 ¿verdad? Dado que todos están vacíos inicialmente, debe ser 0 para todos. compañeros inteligente!

conjetura buena.

del Veamos ahora la salida,

size of the queue q is:80
size of the stack st is:80
size of the vector a is:24

Ups! ¿Qué demonios es eso? ¿Cómo puede ser del tamaño de una cola vacía ser 80? ¿Cómo puede el tamaño de la pila vacía ser 80? ¿Cómo puede el tamaño de un vector vacío ser 24?

se oculta Hay algo?

Sí, la cosa es sizeof le da la memoria de sólo adquirida. Que no se preocupa por cualquier otra cosa. Cada vez que utilizamos STL, existen implementaciones detrás de cada uno de los tipos de STL como una cola, pila, vector, mapas, etc Usted puede encontrar las implementaciones reales detrás de las plantillas y encontrará allí miembros de datos que contribuyen a estas salidas. Por lo que estos objetos casos que tienen algo de memoria ocupadas aunque los que están vacíos.

Bueno, if que haber adivinado que tendrá alguna salida, excepto 0, entonces bien hecho.

Código 2:

#include <bits/stdc++.h>
using namespace std;
int main()
{
int* arr = (int*)(malloc(sizeof(int) * 10));
for (int i = 0; i < 10; i++)
arr[i] = i;
cout << "size of arr is: " << sizeof(arr) << endl;
return 0;
}

Probablemente has adivinado que sea 40 que es sizeof () * 10 = 4 * 10

Está bien! Vamos a ver la salida,

size of arr is: 8

Ups! ¿Cómo puede ser 8 ? Se le debe dar el tamaño de la matriz de la derecha como vimos en el operador Sizeof encontrar parte tamaño de la matriz.

Pero es 8. La razón es su impresión del tamaño del puntero y el compilador generalmente asignado todos los punteros a ser de 8 bytes. Por lo tanto, no es lo mismo que imprimir el tamaño de la matriz ya que es sólo un puntero.

Por lo tanto, la salida es 8

Código 3:

#include <stdio.h>
void f(int a)
{
a = 10;
return;
}
int main()
{
int a = 5;
printf("sizeof function f: %lun", sizeof(f(a)));
return 0;
}

Probablemente has adivinado 0 ya que return void y void significa vacío. Oh, lo has adivinado compilación de error? ¡¡Bravo!!

vamos a ver lo que da salida,

sizeof function f: 1

Esto es algo que puede sorprender, por supuesto. Esto depende del compilador y if ejecuta en GNU compilador de C se encuentra sizeof () para ser 1. Sin embargo, en C ++ se puede tirar de advertencia o de error.

void medio vacía y esto no es de tipo compatible, así, de este modo sizeof () debe producir un error, pero para nuestra sorpresa, en GNU C se da salida a 1, que se debe al compilador que tiene extensión no estándar .

En GNU C, las operaciones de suma y resta son compatibles con punteros a void y en punteros a funciones. Esto se realiza mediante el tratamiento del tamaño de un void o de una función como 1 . Una consecuencia de esto es que sizeof también se permite en void y los tipos de función, y vuelve

espero que este tutorial ha ayudado a conocer operador sizeof bien y que tenía algunos acertijos también. Por último, un hecho muy importante es operador sizeof no se pueden sobrecargar .


Deja un comentario

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