수색…


비고

정수형의 크기 도 참조하십시오.

클래스 유형

"클래스"란 class 또는 struct 키워드를 사용하여 정의 된 유형을 의미합니다 ( enum struct 또는 enum class 제외).

  • 심지어 빈 클래스조차 적어도 하나의 바이트의 저장 공간을 차지합니다. 그러므로 그것은 순전히 패딩으로 이루어져있을 것이다. 이렇게하면 p 가 빈 클래스의 객체를 가리키는 경우 p p + 1 은 고유 한 주소이며 고유 한 객체를 가리 킵니다. 그러나 빈 클래스는 기본 클래스로 사용될 때 크기가 0 일 수 있습니다. 빈 기본 최적화를 참조하십시오.

    class Empty_1 {};                               // sizeof(Empty_1)       == 1
    class Empty_2 {};                               // sizeof(Empty_2)       == 1
    class Derived : Empty_1 {};                     // sizeof(Derived)       == 1
    class DoubleDerived : Empty_1, Empty_2 {};      // sizeof(DoubleDerived) == 1
    class Holder { Empty_1 e; };                    // sizeof(Holder)        == 1
    class DoubleHolder { Empty_1 e1; Empty_2 e2; }; // sizeof(DoubleHolder)  == 2
    class DerivedHolder : Empty_1 { Empty_1 e; };   // sizeof(DerivedHolder) == 2
    
  • 클래스 유형의 객체 표현에는 기본 클래스 및 비 정적 멤버 유형의 객체 표현이 포함됩니다. 따라서 예를 들어, 다음 클래스에서 :

    struct S {
        int x;
        char* y;
    };
    

    하위 객체 라고 부르는 S 객체 내에는 sizeof(int) 바이트의 연속열이 있고 x 값을 포함하고 sizeof(char*) 바이트는 y 값을 포함하는 다른 하위 객체입니다. 두 개는 삽입 할 수 없습니다.

  • 클래스 유형에 유형 t1, t2,...tN 이있는 멤버 및 / 또는 기본 클래스가있는 경우 크기는 앞의 점에서 sizeof(t1) + sizeof(t2) + ... + sizeof(tN) 이상이어야합니다. . 그러나 멤버 및 기본 클래스의 정렬 요구 사항에 따라 컴파일러에서 하위 개체 사이 또는 전체 개체의 시작 또는 끝에 패딩을 삽입해야 할 수 있습니다.

    struct AnInt      { int i; };
      // sizeof(AnInt)        == sizeof(int)
      // Assuming a typical 32- or 64-bit system, sizeof(AnInt)        == 4 (4).
    struct TwoInts    { int i, j; };
      // sizeof(TwoInts)      >= 2 * sizeof(int)
      // Assuming a typical 32- or 64-bit system, sizeof(TwoInts)      == 8 (4 + 4).
    struct IntAndChar { int i; char c; };
      // sizeof(IntAndChar)   >= sizeof(int) + sizeof(char)
      // Assuming a typical 32- or 64-bit system, sizeof(IntAndChar)   == 8 (4 + 1 + padding).
    struct AnIntDerived : AnInt { long long l; };
      // sizeof(AnIntDerived) >= sizeof(AnInt) + sizeof(long long)
      // Assuming a typical 32- or 64-bit system, sizeof(AnIntDerived) == 16 (4 + padding + 8).
    
  • 정렬 요구 사항으로 인해 패딩이 객체에 삽입되면 크기는 멤버 및 기본 클래스 크기의 합보다 커집니다. n 바이트 정렬의 경우 크기는 일반적으로 n 의 최소 ​​배수이며 모든 구성원 및 기본 클래스의 크기보다 큽니다. 각 멤버 memN 은 일반적으로 alignof(memN) 의 배수 인 주소에 배치되며 n 은 일반적으로 모든 멤버의 alignof 중에서 가장 큰 alignof 됩니다. 이 때문에, alignof 가 작은 alignof 이 큰 쪽이 alignof 하면, alignof 이 적절히 정렬되지 않을 가능성이있다. 이 경우 두 멤버 사이에 패딩 ( 정렬 멤버 라고도 함)이 배치되어 후자 멤버가 원하는 정렬을 가질 수 있습니다. 반대로, 더 큰 alignof 을 갖는 멤버 다음에 더 작은 alignof 을 갖는 멤버가 뒤 따르는 경우, 일반적으로 패딩은 필요하지 않습니다. 이 프로세스를 "패킹"이라고도합니다.
    일반적으로 공유 클래스로 인해 alignof 가장 큰 자신의 멤버를 alignof , 클래스는 일반적으로 정렬됩니다 alignof 가 직접 또는 간접적으로 포함하는 가장 큰 내장 타입.

    // Assume sizeof(short) == 2, sizeof(int) == 4, and sizeof(long long) == 8.
    // Assume 4-byte alignment is specified to the compiler.
    struct Char { char c; };
      // sizeof(Char)                == 1 (sizeof(char))
    struct Int  { int i; };
      // sizeof(Int)                 == 4 (sizeof(int))
    struct CharInt { char c; int i; };
      // sizeof(CharInt)             == 8 (1 (char) + 3 (padding) + 4 (int))
    struct ShortIntCharInt { short s; int i; char c; int j; };
      // sizeof(ShortIntCharInt)     == 16 (2 (short) + 2 (padding) + 4 (int) + 1 (char) +
      //                                    3 (padding) + 4 (int))
    struct ShortIntCharCharInt { short s; int i; char c; char d; int j; };
      // sizeof(ShortIntCharCharInt) == 16 (2 (short) + 2 (padding) + 4 (int) + 1 (char) +
      //                                    1 (char) + 2 (padding) + 4 (int))
    struct ShortCharShortInt { short s; char c; short t; int i; };
      // sizeof(ShortCharShortInt)   == 12 (2 (short) + 1 (char) + 1 (padding) + 2 (short) +
      //                                    2 (padding) + 4 (int))
    struct IntLLInt { int i; long long l; int j; };
      // sizeof(IntLLInt)            == 16 (4 (int) + 8 (long long) + 4 (int))
      // If packing isn't explicitly specified, most compilers will pack this as
      //   8-byte alignment, such that:
      // sizeof(IntLLInt)            == 24 (4 (int) + 4 (padding) + 8 (long long) +
      //                                    4 (int) + 4 (padding))
    
    // Assume sizeof(bool) == 1, sizeof(ShortIntCharInt) == 16, and sizeof(IntLLInt) == 24.
    // Assume default alignment: alignof(ShortIntCharInt) == 4, alignof(IntLLInt) == 8.
    struct ShortChar3ArrShortInt {
        short s;
        char c3[3];
        short t;
        int i;
    };
      // ShortChar3ArrShortInt has 4-byte alignment: alignof(int) >= alignof(char) &&
      //                                             alignof(int) >= alignof(short)
      // sizeof(ShortChar3ArrShortInt) == 12 (2 (short) + 3 (char[3]) + 1 (padding) +
      //                                      2 (short) + 4 (int))
      // Note that t is placed at alignment of 2, not 4.  alignof(short) == 2.
    
    struct Large_1 {
        ShortIntCharInt sici;
        bool b;
        ShortIntCharInt tjdj;
    };
      // Large_1 has 4-byte alignment.
        // alignof(ShortIntCharInt) == alignof(int) == 4
        // alignof(b) == 1
        // Therefore, alignof(Large_1) == 4.
      // sizeof(Large_1) == 36 (16 (ShortIntCharInt) + 1 (bool) + 3 (padding) +
      //                        16 (ShortIntCharInt))
    struct Large_2 {
        IntLLInt illi;
        float f;
        IntLLInt jmmj;
    };
      // Large_2 has 8-byte alignment.
        // alignof(IntLLInt) == alignof(long long) == 8
        // alignof(float) == 4
        // Therefore, alignof(Large_2) == 8.
      // sizeof(Large_2) == 56 (24 (IntLLInt) + 4 (float) + 4 (padding) + 24 (IntLLInt))
    
C ++ 11
  • alignas 엄격한 정렬이 강제되는 alignas 에는 패딩을 사용하여 유형이 지정된 정렬을 충족하도록 강제합니다 (그렇지 않으면 작은 경우에도). 예를 들어, 아래의 정의에서 Chars<5> 는 끝에 세 개의 (또는 더 많은) 패딩 바이트를 삽입하여 총 크기가 8이되도록합니다. 정렬이 4 인 클래스는 크기를 가질 수 없습니다 왜냐하면 그 클래스의 배열을 만드는 것은 불가능하기 때문에 크기는 패딩 바이트를 삽입함으로써 4의 배수로 "반올림"되어야합니다.

    // This type shall always be aligned to a multiple of 4.  Padding shall be inserted as
    // needed.
    // Chars<1>..Chars<4> are 4 bytes, Chars<5>..Chars<8> are 8 bytes, etc.
    template<size_t SZ>
    struct alignas(4) Chars { char arr[SZ]; };
    
    static_assert(sizeof(Chars<1>) == sizeof(Chars<4>), "Alignment is strict.\n");
    
  • 클래스의 두 개의 비 정적 멤버가 동일한 액세스 지정자를 갖는 경우 나중에 선언 순서로 제공되는 멤버가 객체 표현에서 나중에 나옵니다. 그러나 두 개의 비 정적 멤버가 다른 액세스 지정자를 갖는 경우 객체 내에서의 상대적 순서는 지정되지 않습니다.
  • 객체 내에서 기본 클래스 하위 객체가 나타나는 순서, 객체가 연속적으로 발생하는지 여부, 구성원 하위 객체의 앞, 뒤에 또는 사이에 나타나는 지 여부는 지정되지 않습니다.

산술 유형

좁은 문자 유형

unsigned char 유형은 모든 비트를 사용하여 2 진수를 나타냅니다. 따라서, 예를 들어, unsigned char 이 8 비트이면 char 객체의 256 가지 가능한 비트 패턴은 256 가지 다른 값 {0, 1, ..., 255}을 나타냅니다. 숫자 42는 비트 패턴 00101010 으로 표시되도록 보장됩니다.

signed char 타입은 패딩 비트를 갖지 않는다. 즉, signed char 가 8 비트이면, 8 비트의 숫자를 표현할 수있다.

이러한 보증은 좁은 문자 유형 이외의 유형에는 적용되지 않습니다.

정수 유형

부호없는 정수 유형은 순수한 이진 시스템을 사용하지만 패딩 비트를 포함 할 수 있습니다. 예를 들어, 경우 (거의 발생하지 않지만) 가능 unsigned int 1 (포함) - 64 비트 길이 일 수 있지만 0 2 32 사이의 정수 저장 가능하도록. 나머지 32 비트는 패딩 비트가 될 것이고 직접적으로 쓰여서는 안됩니다.

부호있는 정수 유형은 부호 비트와 가능하면 패딩 비트가있는 2 진 시스템을 사용합니다. 부호가있는 정수 유형과 해당 부호없는 정수 유형의 공통 범위에 속하는 값은 동일한 표현을 갖습니다. 예를 들어, unsigned short 오브젝트의 비트 패턴 0001010010101011 이 값 5291 을 나타내는 경우, short 오브젝트로 해석 될 때 값 5291 나타냅니다.

세 개의 시스템 모두 이전 단락의 요구 사항을 충족하므로 2의 보수, 1의 보수 또는 부호 크기 표현이 사용되는지 여부는 구현에 따라 결정됩니다.

부동 소수점 유형

부동 소수점 형의 값 표현은 구현에 따라 정의됩니다. 가장 일반적으로, floatdouble 유형은 IEEE 754를 따르며 32 비트 및 64 비트 길이입니다 (예를 들어, float 는 23 비트의 지수와 8 비트의 지수 비트를 따르게됩니다). 그러나이 표준은 아무 것도 보장하지 않습니다. 부동 소수점 유형에는 종종 "트랩 표현"이있어 계산에 사용될 때 오류가 발생합니다.

배열

배열 유형에는 요소 사이에 패딩이 없습니다. 따라서 요소 유형이 T 인 배열은 메모리에 배열 된 T 객체의 순서입니다.

다차원 배열은 배열의 배열이며 위 내용은 반복적으로 적용됩니다. 예를 들어, 선언이있는 경우

int a[5][3];

다음 a 3/5 배열의 배열 int 들. 따라서, a[0] , 세 개의 요소들로 구성되는 a[0][0] , a[0][1] , a[0][2] , 이전에 메모리에 뻗어있다 a[1] , 이는이 이루어져 a[1][0] , a[1][1]a[1][2] 이를 행 주요 순서라고 합니다 .



Modified text is an extract of the original Stack Overflow Documentation
아래 라이선스 CC BY-SA 3.0
와 제휴하지 않음 Stack Overflow