directorio
escenarios de aplicación específicos sizeof
El tamaño del espacio ocupado por la clase de objeto
El tamaño función virtual que contiene el espacio de clase de objeto
La diferencia entre sizeof y strlen
sizeof (str) / sizeof (str [0])
Cálculo del tamaño de la Commonwealth
#pragma pack (x) para forzar el compilador para modificar la alineación
escenarios de aplicación específicos sizeof
- Unidad de ver un objeto del espacio de memoria de tipo byte ocupada.
- Cuando un objeto asignado dinámicamente, puede dejar que el sistema sepa la cantidad de memoria para asignar.
- Algunos tipos de fácil expansión, en algunas plataformas (tales como ventanas, Python), crean una variable, el número variable almacenada en la memoria, como una propiedad directamente sobre las propiedades de esta variable entre.
- Algunos operandos cuando está en uso, no habrá cambios en tiempo real, por lo que puede utilizar la observación en tiempo real y grabación de memoria sizeof para la situación.
- Si el sizeof objeto lleva a cabo, o el parámetro de la función es una matriz, devolverá directamente tamaño sizeof de su puntero.
tipos de datos comunes Tamaño
- tipo int: 4 bits
- Tipo de corta: 2bit
- tipo largo: de 4 bits
- tipo char: 1 bit
- doble Tipo: de 8 bits
- tipo bool: 1 bit
- tipo float: 4 bits
- tipo de puntero: 4 bits
- Tipo de cadena: "char str [] =" Hola ";", que agregar longitud a la última (porque hay una última "\ n" existe símbolo marcador de posición), (5 + 1 = 6)
En una palabra, la mayoría de ellos son de 4 bits, la más larga de las cuales es de 8 bits (tipo doble), y el más pequeño es de 1 bit (char y bool).
El tamaño del espacio ocupado por la clase de objeto
Primero debemos entender una cosa, se crea el tamaño de la clase de objeto, no después de todas las variables se acumularán clase simple venir, en lugar de utilizar de forma acolchada calculada por venir!
Tamaño de la clase debe ser un múltiplo entero del tamaño máximo elemento de sus miembros internos (esencialmente, cuando los datos se almacenan en una clase, un miembro de los primeros datos almacenados en el offset es 0 lugar, entonces, después de que los miembros de datos son se almacena desde la posición inicial después del comienzo del almacenamiento de un múltiplo entero del tamaño de un miembro).
#include <stdio.h>
#include <iostream>
class A
{
public:
int i;
};
class B
{
public:
char ch;
private:
};
class C
{
public:
int i;
short j;
private:
};
class D
{
public:
int i;
short j;
char ch;
private:
};
class E
{
public:
int i;
int ii;
short j;
char ch;
char chr;
private:
};
class F
{
public:
int i;
int ii;
int iii;
short j;
char ch;
char chr;
private:
};
int main()
{
printf("sizeof(int) = %d\n", sizeof(int));
printf("sizeof(short) = %d\n", sizeof(short));
printf("sizeof(char) = %d\n", sizeof(char));
printf("sizeof(A) = %d\n", sizeof(A));
printf("sizeof(B) = %d\n", sizeof(B));
printf("sizeof(C) = %d\n", sizeof(C));
printf("sizeof(D) = %d\n", sizeof(D));
printf("sizeof(E) = %d\n", sizeof(E));
printf("sizeof(F) = %d\n", sizeof(F));
system("pause");
return 0;
}Ejecutar la siguiente manera:
Una clase comprende: un INT> sizeof (A) = sizeof (int) = 4;
Clase B que comprende: una carac-> sizeof (B) = sizeof (char) = 1;
Clase C comprende: un int (4 bytes) 1 corto (2 bytes) -> sizeof (C) = 4 + 2 = 6, ya que 6 no es un múltiplo entero de 4, por lo tanto, de complemento a dos, para dar 8;
Clase D que comprende: un int (4 bytes) 1 corto (4 bytes) 1 char (1 byte) -> sizeof (D) = 4+ (2 + 1) = 7, 7 no es tan número entero múltiplo de 4, de modo que 1 para dar 8;
Clase E: 4 + 4 + 2 + 1 + 1 = 12, es un múltiplo entero de 4, para obtener 12;
Clase F: 4 + 4 + 4 + 2 + 1 + 1 = 16, es un múltiplo entero de 4, para obtener 16;
El resultado de la determinación, y añadiendo el resultado de ver, que no es un múltiplo entero de la mayor sumando, si es así, se puede, si no, para compensar el número mínimo, por lo que es un múltiplo entero de la mayor sumando.
El tamaño función virtual que contiene el espacio de clase de objeto
La función normal no ocupa memoria, pero siempre y cuando no es una función virtual, que ocupará un tamaño de memoria de un puntero (que es una función virtual en la tabla de función virtual contiene la razón), por lo que el número de clase tiene funciones virtuales, con el equivalente varias variables puntero (4 bytes).
A continuación, dos juegos de la función de herencia se fija con funciones virtuales, sin lugar a Talia, diferencias muy evidentes:
#include <stdio.h>
#include <iostream>
using namespace std;
class Base
{
public:
Base(int x) :a(x)
{
}
void print()
{
printf("base\n");
}
private:
int a;
};
class Derived:public Base
{
public:
Derived(int x) :Base(x - 1), b(x)
{
}
void print()
{
printf("derived\n");
}
private:
int b;
};
class A
{
public:
A(int x) :a(x)
{
}
virtual void print()
{
printf("A");
}
private:
int a;
};
class B:public A
{
public:
B(int x) :A(x - 1), b(x)
{
}
virtual void print()
{
printf("B");
}
private:
int b;
};
int main()
{
Base obj1(1);
printf("sizeof(Base obj1):%d\n", sizeof(obj1));
Derived obj2(2);
printf("sizeof(Base obj2):%d\n", sizeof(obj2));
A a(1);
printf("sizeof(A a):%d\n", sizeof(a));
B b(2);
printf("sizeof(B b):%d\n", sizeof(b));
system("pause");
return 0;
}Debe tenerse en cuenta que la siguiente se compila en el entorno x86, el resultado está en línea con lo esperado:
Para la base, que tiene una int, clase base para que se crea el tamaño del objeto de 4 bytes; para la derivada, que tiene un tipo de int, y esta clase que hereda de Base es más, lo que añadir 4 sobre la base de Base , es decir, 8 bytes;
Del mismo modo, cuando A es 4 + 4 (Int un tipo de función virtual +) = 8; A entonces B sobre la base de la (en este momento no es una función virtual se llama, de manera que el recuento no es de cuatro palabras de las funciones virtuales sección) también se añade y una función virtual tipo Int: 4 + 4 + 4 = 12.
Pero si se está ejecutando en 64 bits:
El resultado no es el mismo que antes y las (razones específicas, después de verificación).
Nota: si la clase contiene las variables estáticas, variables estáticas de clase y espacio de memoria se almacenan en la variable local no está presente en el espacio de memoria juntos, de manera que, cuando la clase contiene las variables estáticas para calcular el uso sizeof, que, sin encontrar calcular el tamaño de la cuota variable estática.
La diferencia entre sizeof y strlen
- Es operador sizeof, strlen es una definición de función.
- tipo sizeof se puede utilizar como un parámetro, tal como sizeof (int), pero no strlen solamente y, específicamente cadena strlen medido con strlen (char * a) ,, el objeto debe ser "\ 0" al final.
- Cuando la matriz como un parámetro sizeof no se degrada como un puntero, pero la función del tiempo como un parámetro, un puntero a degenerada
- sizeof durante la compilación apagar el resultado calculado (como es el tipo de operador), pero sólo debe ser strlen resultados en la operación (como es la longitud del operador de cadena).
- sizeof cuando está en uso, si este último es de un tipo, es paréntesis necesarias: sizeof (int), pero si es variable, no hay necesidad de soportes: sizeof a, porque sizeof es un operador, no una función.
Si se calcula el puntero a la longitud de la cadena, debe strlen,
matriz de cadenas de tienda
Por ejemplo:
#include <stdio.h>
#include <iostream>
using namespace std;
int main()
{
char str[20] = "0123456";
int a = sizeof(str);
printf("a:%d\n", a);
int b = strlen(str);
printf("b:%d\n", b);
system("pause");
return 0;
}
trastorno anterior se produce, y consiste en el cálculo de la duración del tiempo de la cadena, para utilizar strlen.
Puntero a la cadena
#include <stdio.h>
#include <iostream>
using namespace std;
int main()
{
const char* ss = "0123456";
int a = sizeof(ss);
printf("a:%d\n", a);
int b = strlen(ss);
printf("b:%d\n", b);
system("pause");
return 0;
}El resultado:
Uso sizeof para calcularlo, o no se les permite, será más bien un carácter "\ 0".
En una palabra, sizeof no se puede utilizar para calcular la longitud de la cadena, que puede ser utilizado strlen.
sizeof (str) / sizeof (str [0])
Este comando es el número de todos los elementos de la matriz str cálculo, el número no es válido para el cálculo de los elementos de la matriz, hay que distinguir con claridad!
Cálculo del tamaño de la Commonwealth
Commonwealth depende de:
- Tamaño de todos los miembros del tamaño del espacio ocupado por uno de los miembros más grandes de la (única unión)
- Un múltiplo entero de la longitud de la alineación de tipos de datos como un miembro de la miembro más grande de (y unión, struct, clase en la misma alineación)
Ver el siguiente código,
#include <stdio.h>
#include <iostream>
using namespace std;
union u0
{
int i;
double j;
};
union u1
{
char a[13];
int i;
};
union u2
{
char a[13];
char b;
};
int main()
{
printf("u0:%d\n", sizeof(u0));
printf("u1：%d\n", sizeof(u1));
printf("u2:%d\n", sizeof(u2));
system("pause");
return 0;
}Mira u0, dentro de un doble (8), un int (4), unión depende del tipo de los que el período máximo de almacenamiento, está claro que el mayor tipo de matrimonio, luego 8, vistazo a la alineación no hay ningún problema, sin problema, es un múltiplo de 8. 8.
u1 Look, que tiene una matriz de caracteres, una variable, por lo tanto, como un tipo (tamaño 13), y int (4 bytes), entonces el máximo para encontrar el tipo de almacenado 13, de nuevo, el principio de la alineación, el tamaño char (1 byte), el tamaño int es 4, y que la unión debe ser un múltiplo entero de la talla 4, de modo que (13 + 3) = 16, alrededor de un múltiplo entero de 4. (Nota que la particularidad de la matriz, y el tamaño de la unidad mínima, en otras palabras, para ver la alineación de tiempo, la unidad mínima de la matriz es un char 1 byte)
Del mismo modo, u2, que es 13, pero el número máximo de bytes en un char (1 byte a), 1 es un múltiplo entero de 13, por lo que 13
Los resultados son los siguientes:
#pragma pack (x) para forzar el compilador para modificar la alineación
La clase por encima de C a cabo, de conformidad con el funcionamiento normal, el tamaño de C debe ser de 8, debido a la alineación (clase C incluye: un int (4 bytes) 1 corto (2 bytes) -> sizeof ( C) = 4 + 2 = 6, ya que 6 no es un múltiplo entero de 4, por lo tanto, de complemento a dos, para dar 8;). Pero yo uso #pragma pack (1), obligado a alinear la unidad mínima se establece en 1, por lo que el tamaño de la clase, se hace directamente a la clase de tipo de variable se acumulan en la línea!
#include <stdio.h>
#include <iostream>
using namespace std;
#pragma pack(1)
class C
{
public:
int i;
short j;
private:
};
int main()
{
printf("c:%d\n", sizeof(C)); //原来因为要对齐int类型，结果为8
system("pause");
return 0;
}
