your programing

C ++ 표준은 int, long 유형의 크기를 무엇으로 지정합니까?

lovepro 2020. 9. 30. 11:13
반응형

C ++ 표준은 int, long 유형의 크기를 무엇으로 지정합니까?

기본 C ++ 유형의 크기에 대한 자세한 정보를 찾고 있습니다. 아키텍처 (16 비트, 32 비트, 64 비트)와 컴파일러에 따라 다르다는 것을 알고 있습니다.

하지만 C ++에 대한 표준이 있습니까?

32 비트 아키텍처에서 Visual Studio 2008을 사용하고 있습니다. 내가 얻는 것은 다음과 같습니다.

char  : 1 byte
short : 2 bytes
int   : 4 bytes
long  : 4 bytes
float : 4 bytes
double: 8 bytes

나는의 크기를 나타 신뢰할 수있는 정보를, 많은 성공없이 찾을려고 char, short, int, long, double, float다른 아키텍처와 컴파일러에서 (그리고 다른 종류의 내가 생각하지 않았다).

C ++ 표준은 정수 유형의 크기를 바이트로 지정하지 않지만 보유 할 수 있어야하는 최소 범위를 지정합니다. 필요한 범위에서 최소 크기 (비트)를 추론 할 수 있습니다. 그로부터 바이트 단위의 최소 크기와 바이트 의 비트 수CHAR_BIT 를 정의하는 매크로 값을 추론 할 수 있습니다 . 가장 모호한 플랫폼을 제외한 모든 플랫폼에서는 8이고 8보다 작을 수 없습니다. "유니 코드 UTF-8 인코딩 형식의 8 비트 코드 단위"를 수용 할 수있을만큼 충분히 커야하기 때문입니다.

한 가지 추가 제약 char은 크기가 항상 1 바이트 또는 CHAR_BIT비트 (따라서 이름)라는 것입니다. 이는 표준에 명시되어 있습니다.

C 표준은 C ++ 표준에 대한 표준 참조 이므로 이러한 요구 사항을 명시 적으로 명시하지 않더라도 C ++에는 C 표준 (22 페이지)에서 요구하는 최소 범위가 필요합니다 . MSDN :

  1. signed char: -127 ~ 127 (참고, -128 ~ 127이 아님, 1의 보수 및 부호 및 크기 플랫폼 수용)
  2. unsigned char: 0 ~ 255
  3. "plain" char: signed char또는 과 동일한 범위 unsigned char, 구현 정의
  4. signed short: -32767에서 32767
  5. unsigned short: 0에서 65535
  6. signed int: -32767에서 32767
  7. unsigned int: 0에서 65535
  8. signed long: -2147483647에서 2147483647
  9. unsigned long: 0에서 4294967295
  10. signed long long: -9223372036854775807 ~ 9223372036854775807
  11. unsigned long long: 0에서 18446744073709551615

C ++ (또는 C) 구현은 유형의 크기를 바이트 단위 sizeof(type)로 정의 할 수 있습니다.

  1. 표현식 sizeof(type) * CHAR_BIT은 필요한 범위를 포함하기에 충분히 높은 비트 수로 평가됩니다.
  2. 유형의 순서는 여전히 유효합니다 (예 :) sizeof(int) <= sizeof(long).

이 모든 것을 종합하면 다음을 보장합니다.

  • char, signed char및 unsigned char적어도 8 비트는
  • signed short, unsigned short, signed int및 unsigned int적어도 16 비트이다
  • signed long그리고 unsigned long적어도 32 비트이다
  • signed long long그리고 unsigned long long적어도 64 비트이다

보장의 크기 이루어지지 않습니다 float또는 double그 제외 double만큼의 정밀도로 적어도 제공합니다 float.

실제 구현 특정 범위는 <limits.h>C의 헤더 또는 <climits>C ++ (또는 헤더의 템플릿) std::numeric_limits에서 찾을 수 있습니다 <limits>.

예를 들어, 다음은에 대한 최대 범위를 찾는 방법입니다 int.

씨:

#include <limits.h>
const int min_int = INT_MIN;
const int max_int = INT_MAX;

C ++ :

#include <limits>
const int min_int = std::numeric_limits<int>::min();
const int max_int = std::numeric_limits<int>::max();

32 비트 시스템의 경우 '사실상'표준은 ILP32입니다. 즉 int,, long포인터는 모두 32 비트 수량입니다.

64 비트 시스템의 경우 기본 Unix '사실상'표준은 LP64 long이며 포인터는 64 비트 (그러나 int32 비트)입니다. - 윈도우 64 비트 표준은 LLP64이다 long long포인터는 64 비트이다 (그러나 long및 int32 비트이다).

한때 일부 Unix 시스템은 ILP64 조직을 사용했습니다.

이러한 사실상의 표준 중 어느 것도 C 표준 (ISO / IEC 9899 : 1999)에 의해 입법화되지 않았지만 모두 허용됩니다.

그리고, 정의, sizeof(char)인 1펄 구성 스크립트 테스트에도 불구하고,.

기계 (Crays)가 있었다하는 것으로 CHAR_BIT의미 그건 8. IIRC보다 훨씬 더이었다, sizeof(int)또한 1이었고, 때문에 모두 char와 int있었다 32 비트.

실제로 그런 것은 없습니다. std::size_t현재 아키텍처에서 부호없는 기본 정수 크기를 나타낼 수 있습니다 . 즉, 16 비트, 32 비트 또는 64 비트이지만이 답변에 대한 주석에서 지적한대로 항상 그런 것은 아닙니다.

다른 모든 내장 유형이 진행되는 한 실제로 컴파일러에 따라 다릅니다. 다음은 최신 C ++ 표준의 현재 작업 초안에서 발췌 한 두 가지입니다.

표준 부호있는 정수 유형에는 부호있는 char, short int, int, long int 및 long long int의 다섯 가지 표준이 있습니다. 이 목록에서 각 유형은 목록에있는 이전 유형보다 최소한 많은 스토리지를 제공합니다.

각각의 표준 부호있는 정수 유형에 대해 해당하는 (그러나 다른) 표준 부호없는 정수 유형이 있습니다. 동일한 정렬 요구 사항이 있습니다.

원하는 경우 이러한 기본 유형의 크기를 정적으로 (컴파일시) 주장 할 수 있습니다. 가정의 크기가 변경되면 사람들에게 코드 이식에 대해 생각하도록 경고합니다.

표준이 있습니다.

C90 표준은

sizeof(short) <= sizeof(int) <= sizeof(long)

C99 표준은

sizeof(short) <= sizeof(int) <= sizeof(long) <= sizeof(long long)

다음은 C99 사양 입니다. 22 페이지는 다양한 정수 유형의 크기를 자세히 설명합니다.

다음은 Windows 플랫폼의 int 유형 크기 (비트)입니다.

Type           C99 Minimum     Windows 32bit
char           8               8
short          16              16
int            16              32
long           32              32
long long      64              64

이식성에 관심이 있거나 유형 이름에 크기가 반영되도록 <inttypes.h>하려면 다음 매크로를 사용할 수 있는 헤더 를 볼 수 있습니다.

int8_t
int16_t
int32_t
int64_t

int8_t8 비트 int16_t가 보장되고 16 비트 등이 보장됩니다.

고정 크기 유형이 필요한 경우 stdint.h에 정의 된 uint32_t (부호없는 정수 32 비트)와 같은 유형을 사용하십시오 . 그들은 C99 에 지정되어 있습니다.

업데이트 : C ++ 11은 TR1의 형식을 공식적으로 표준으로 가져 왔습니다.

  • long long int
  • unsigned long long 정수

그리고 "크기"유형 <cstdint>

  • int8_t
  • int16_t
  • int32_t
  • int64_t
  • (및 서명되지 않은 대응 물).

또한 다음을 얻을 수 있습니다.

  • int_least8_t
  • int_least16_t
  • int_least32_t
  • int_least64_t
  • 더하기 서명되지 않은 대응 물.

이러한 유형은 지정된 비트 수 이상의 가장 작은 정수 유형을 나타냅니다. 마찬가지로 최소한 지정된 비트 수를 가진 "가장 빠른"정수 유형이 있습니다.

  • int_fast8_t
  • int_fast16_t
  • int_fast32_t
  • int_fast64_t
  • 또한 서명되지 않은 버전도 있습니다.

"빠름"이 의미하는 바는 구현에 달려 있습니다. 모든 목적에서 가장 빠를 필요는 없습니다.

C ++ 표준 이처럼 말한다 :

3.9.1, §2 :

부호있는 정수 유형에는 "signed char", "short int", "int", "long int"및 "long long int"의 다섯 가지가 있습니다. 이 목록에서 각 유형은 목록에있는 이전 유형보다 최소한 많은 스토리지를 제공합니다. Plain int는 실행 환경의 아키텍처에서 제안한 자연스러운 크기를 갖습니다 (44). 다른 부호있는 정수 유형은 특별한 요구를 충족하기 위해 제공됩니다.

(44) 즉 , 헤더에 정의 된대로 INT_MIN 및 INT_MAX 범위의 값을 포함 할만큼 충분히 큽니다<climits> .

결론 : 작업중인 아키텍처에 따라 다릅니다. 다른 가정은 거짓입니다.

아니요, 유형 크기에 대한 표준은 없습니다. Standard는 다음 사항 만 요구합니다.

sizeof(short int) <= sizeof(int) <= sizeof(long int)

고정 된 크기의 변수를 원할 때 할 수있는 가장 좋은 방법은 다음과 같은 매크로를 사용하는 것입니다.

#ifdef SYSTEM_X
  #define WORD int
#else
  #define WORD long int
#endif

그런 다음 WORD를 사용하여 변수를 정의 할 수 있습니다. 내가 이것을 좋아하는 것은 아니지만 가장 휴대 가능한 방법입니다.

유형에 대한 동의어를 정의하여 자체 "표준"을 만들 수 있습니다.

sizeof (int) == 4 인 머신에서 다음을 정의 할 수 있습니다.

typedef int int32;

int32 i;
int32 j;
...

따라서 실제로 long int의 크기가 4 인 다른 컴퓨터로 코드를 전송할 때 int의 단일 발생을 재정의 할 수 있습니다.

typedef long int int32;

int32 i;
int32 j;
...

부동 소수점 숫자의 경우 표준 (IEEE754)이 있습니다 . float는 32 비트이고 double은 64입니다. 이것은 C ++ 표준이 아닌 하드웨어 표준이므로 컴파일러는 이론적으로 float 및 double을 다른 크기로 정의 할 수 있지만 실제로는 다른 것을 사용한 아키텍처는 본 적이 없습니다.

표준이 있으며 다양한 표준 문서 (ISO, ANSI 및 기타)에 지정되어 있습니다.

Wikipedia에는 ​​다양한 유형과 저장할 수있는 최대 값을 설명하는 훌륭한 페이지가 있습니다. Integer in Computer Science.

그러나 표준 C ++ 컴파일러를 사용하더라도 다음 코드 조각을 사용하여 비교적 쉽게 찾을 수 있습니다.

#include <iostream>
#include <limits>


int main() {
    // Change the template parameter to the various different types.
    std::cout << std::numeric_limits<int>::max() << std::endl;
}

std :: numeric_limits에 대한 문서 는 Roguewave 에서 찾을 수 있습니다 . 여기에는 다양한 제한을 알아 내기 위해 호출 할 수있는 다른 명령이 많이 포함되어 있습니다. 크기를 전달하는 임의의 유형 (예 : std :: streamsize)과 함께 사용할 수 있습니다.

John의 대답에는 최고의 설명이 포함되어 있습니다. 어떤 플랫폼을 사용하든 각 유형에 포함되어야하는 비트 수에 대해 자세히 설명하는 또 다른 좋은 페이지가 있습니다. int types , 이는 표준에 정의되어 있습니다.

이게 도움이 되길 바란다!

1) 문서의 표 N1 " 64 비트 프로그램 개발의 잊혀진 문제 "

2) " 데이터 모델 "

당신이 사용할 수있는:

cout << "size of datatype = " << sizeof(datatype) << endl;

datatype = int, long int등. 입력 한 데이터 유형에 대한 크기를 볼 수 있습니다.

다른 아키텍처 및 다른 컴파일러에 대한 내장 유형의 경우 컴파일러와 함께 아키텍처에서 다음 코드를 실행하여 출력 내용을 확인하십시오. 아래는 Ubuntu 13.04 (Raring Ringtail) 64 비트 g ++ 4.7.3 출력을 보여줍니다 . 또한 출력이 다음과 같이 주문 된 이유가 무엇인지 아래에 답변 한 내용에 유의하십시오.

"부호화 된 char, short int, int, long int 및 long long int의 다섯 가지 표준 부호있는 정수 유형이 있습니다.이 목록에서 각 유형은 적어도 목록에있는 이전 유형만큼 많은 스토리지를 제공합니다."

#include <iostream>

int main ( int argc, char * argv[] )
{
  std::cout<< "size of char: " << sizeof (char) << std::endl;
  std::cout<< "size of short: " << sizeof (short) << std::endl;
  std::cout<< "size of int: " << sizeof (int) << std::endl;
  std::cout<< "size of long: " << sizeof (long) << std::endl;
  std::cout<< "size of long long: " << sizeof (long long) << std::endl;

  std::cout<< "size of float: " << sizeof (float) << std::endl;
  std::cout<< "size of double: " << sizeof (double) << std::endl;

  std::cout<< "size of pointer: " << sizeof (int *) << std::endl;
}


size of char: 1
size of short: 2
size of int: 4
size of long: 8
size of long long: 8
size of float: 4
size of double: 8
size of pointer: 8

언급했듯이 크기는 현재 아키텍처를 반영해야합니다. limits.h현재 컴파일러가 작업을 처리하는 방법을보고 싶다면 정점을 찍을 수 있습니다 .

다른 사람들이 대답했듯이 "표준"은 대부분의 세부 사항을 "구현 정의"로 남겨두고 "char"유형이 "char_bis"너비에 있고 "char <= short <= int <= long < = long long "(float 및 double은 IEEE 부동 소수점 표준과 거의 일치하며 long double은 일반적으로 double과 동일하지만 현재 구현에서는 더 클 수 있음).

매우 구체적이고 정확한 값이없는 이유 중 하나는 C / C ++와 같은 언어가 "char"단어 크기가 4 비트 일 수있는 컴퓨터 시스템을 포함하여 다수의 하드웨어 플랫폼에 이식 가능하도록 설계 되었기 때문입니다. 또는 7 비트 또는 일반 가정용 컴퓨터 사용자가 노출되는 "8- / 16- / 32- / 64- 비트"컴퓨터 이외의 값. (여기서 단어 크기는 시스템이 일반적으로 작동하는 비트 폭을 의미합니다. 다시 말하지만 가정용 컴퓨터 사용자가 예상하는 것처럼 항상 8 비트는 아닙니다.)

If you really need a object (in the sense of a series of bits representing an integral value) of a specific number of bits, most compilers have some method of specifying that; But it's generally not portable, even between compilers made by the ame company but for different platforms. Some standards and practices (especially limits.h and the like) are common enough that most compilers will have support for determining at the best-fit type for a specific range of values, but not the number of bits used. (That is, if you know you need to hold values between 0 and 127, you can determine that your compiler supports an "int8" type of 8-bits which will be large enought to hold the full range desired, but not something like an "int7" type which would be an exact match for 7-bits.)

참고 : 많은 Un * x 소스 패키지는 컴파일러 / 시스템의 기능을 조사하고 적합한 Makefile 및 config.h를 출력하는 "./configure"스크립트를 사용했습니다. 이러한 스크립트 중 일부를 검사하여 작동 방식과 컴파일러 / 시스템 기능을 조사하는 방식을 확인하고 리드를 따를 수 있습니다.

순수한 C ++ 솔루션에 관심이 있다면 템플릿과 C ++ 표준 코드 만 사용하여 컴파일 타임에 비트 크기에 따라 유형을 정의했습니다. 이를 통해 컴파일러간에 솔루션을 이식 할 수 있습니다.

기본 개념은 매우 간단합니다. char, int, short, long, long long (서명 된 버전과 서명되지 않은 버전) 유형을 포함하는 목록을 만들고 목록을 스캔하고 numeric_limits 템플릿을 사용하여 주어진 크기의 유형을 선택합니다.

이 헤더를 포함하여 8 개의 유형 stdtype :: int8, stdtype :: int16, stdtype :: int32, stdtype :: int64, stdtype :: uint8, stdtype :: uint16, stdtype :: uint32, stdtype :: uint64가 있습니다.

어떤 유형을 표현할 수없는 경우 해당 헤더에도 선언 된 stdtype :: null_type으로 평가됩니다.

아래 코드는 보증없이 제공됩니다. 두 번 확인하십시오.
저는 METAPROGRAMMING에 너무 익숙합니다.이 코드를 자유롭게 편집하고 수정할 수 있습니다.
DevC ++로 테스트 됨 (따라서 3.5 정도의 gcc 버전)

#include <limits>

namespace stdtype
{
    using namespace std;


    /*
     * THIS IS THE CLASS USED TO SEMANTICALLY SPECIFY A NULL TYPE.
     * YOU CAN USE WHATEVER YOU WANT AND EVEN DRIVE A COMPILE ERROR IF IT IS 
     * DECLARED/USED.
     *
     * PLEASE NOTE that C++ std define sizeof of an empty class to be 1.
     */
    class null_type{};

    /*
     *  Template for creating lists of types
     *
     *  T is type to hold
     *  S is the next type_list<T,S> type
     *
     *  Example:
     *   Creating a list with type int and char: 
     *      typedef type_list<int, type_list<char> > test;
     *      test::value         //int
     *      test::next::value   //char
     */
    template <typename T, typename S> struct type_list
    {
        typedef T value;
        typedef S next;         

    };




    /*
     * Declaration of template struct for selecting a type from the list
     */
    template <typename list, int b, int ctl> struct select_type;


    /*
     * Find a type with specified "b" bit in list "list"
     *
     * 
     */
    template <typename list, int b> struct find_type
    {   
        private:
            //Handy name for the type at the head of the list
            typedef typename list::value cur_type;

            //Number of bits of the type at the head
            //CHANGE THIS (compile time) exp TO USE ANOTHER TYPE LEN COMPUTING
            enum {cur_type_bits = numeric_limits<cur_type>::digits};

        public:
            //Select the type at the head if b == cur_type_bits else
            //select_type call find_type with list::next
            typedef  typename select_type<list, b, cur_type_bits>::type type;
    };

    /*
     * This is the specialization for empty list, return the null_type
     * OVVERRIDE this struct to ADD CUSTOM BEHAVIOR for the TYPE NOT FOUND case
     * (ie search for type with 17 bits on common archs)
     */
    template <int b> struct find_type<null_type, b>
    {   
        typedef null_type type;

    };


    /*
     * Primary template for selecting the type at the head of the list if
     * it matches the requested bits (b == ctl)
     *
     * If b == ctl the partial specified templated is evaluated so here we have
     * b != ctl. We call find_type on the next element of the list
     */
    template <typename list, int b, int ctl> struct select_type
    {   
            typedef  typename find_type<typename list::next, b>::type type; 
    };

    /*
     * This partial specified templated is used to select top type of a list
     * it is called by find_type with the list of value (consumed at each call)
     * the bits requested (b) and the current type (top type) length in bits
     *
     * We specialice the b == ctl case
     */
    template <typename list, int b> struct select_type<list, b, b>
    {
            typedef typename list::value type;
    };


    /*
     * These are the types list, to avoid possible ambiguity (some weird archs)
     * we kept signed and unsigned separated
     */

    #define UNSIGNED_TYPES type_list<unsigned char,         \
        type_list<unsigned short,                           \
        type_list<unsigned int,                             \
        type_list<unsigned long,                            \
        type_list<unsigned long long, null_type> > > > >

    #define SIGNED_TYPES type_list<signed char,         \
        type_list<signed short,                         \
        type_list<signed int,                           \
        type_list<signed long,                          \
        type_list<signed long long, null_type> > > > >



    /*
     * These are acutally typedef used in programs.
     * 
     * Nomenclature is [u]intN where u if present means unsigned, N is the 
     * number of bits in the integer
     *
     * find_type is used simply by giving first a type_list then the number of 
     * bits to search for.
     *
     * NB. Each type in the type list must had specified the template 
     * numeric_limits as it is used to compute the type len in (binary) digit.
     */
    typedef find_type<UNSIGNED_TYPES, 8>::type  uint8;
    typedef find_type<UNSIGNED_TYPES, 16>::type uint16;
    typedef find_type<UNSIGNED_TYPES, 32>::type uint32;
    typedef find_type<UNSIGNED_TYPES, 64>::type uint64;

    typedef find_type<SIGNED_TYPES, 7>::type    int8;
    typedef find_type<SIGNED_TYPES, 15>::type   int16;
    typedef find_type<SIGNED_TYPES, 31>::type   int32;
    typedef find_type<SIGNED_TYPES, 63>::type   int64;

}

unsigned char bits = sizeof(X) << 3;

여기서 XA는 char, int, long등 당신의 크기를 줄 것이다 X비트를.

From Alex B The C++ standard does not specify the size of integral types in bytes, but it specifies minimum ranges they must be able to hold. You can infer minimum size in bits from the required range. You can infer minimum size in bytes from that and the value of the CHAR_BIT macro that defines the number of bits in a byte (in all but the most obscure platforms it's 8, and it can't be less than 8).

One additional constraint for char is that its size is always 1 byte, or CHAR_BIT bits (hence the name).

Minimum ranges required by the standard (page 22) are:

and Data Type Ranges on MSDN:

signed char: -127 to 127 (note, not -128 to 127; this accommodates 1's-complement platforms) unsigned char: 0 to 255 "plain" char: -127 to 127 or 0 to 255 (depends on default char signedness) signed short: -32767 to 32767 unsigned short: 0 to 65535 signed int: -32767 to 32767 unsigned int: 0 to 65535 signed long: -2147483647 to 2147483647 unsigned long: 0 to 4294967295 signed long long: -9223372036854775807 to 9223372036854775807 unsigned long long: 0 to 18446744073709551615 A C++ (or C) implementation can define the size of a type in bytes sizeof(type) to any value, as long as

the expression sizeof(type) * CHAR_BIT evaluates to the number of bits enough to contain required ranges, and the ordering of type is still valid (e.g. sizeof(int) <= sizeof(long)). The actual implementation-specific ranges can be found in header in C, or in C++ (or even better, templated std::numeric_limits in header).

For example, this is how you will find maximum range for int:

C:

#include <limits.h>
const int min_int = INT_MIN;
const int max_int = INT_MAX;

C++:

#include <limits>
const int min_int = std::numeric_limits<int>::min();
const int max_int = std::numeric_limits<int>::max();

This is correct, however, you were also right in saying that: char : 1 byte short : 2 bytes int : 4 bytes long : 4 bytes float : 4 bytes double : 8 bytes

Because 32 bit architectures are still the default and most used, and they have kept these standard sizes since the pre-32 bit days when memory was less available, and for backwards compatibility and standardization it remained the same. Even 64 bit systems tend to use these and have extentions/modifications. Please reference this for more information:

http://en.cppreference.com/w/cpp/language/types

I notice that all the other answers here have focused almost exclusively on integral types, while the questioner also asked about floating-points.

I don't think the C++ standard requires it, but compilers for the most common platforms these days generally follow the IEEE754 standard for their floating-point numbers. This standard specifies four types of binary floating-point (as well as some BCD formats, which I've never seen support for in C++ compilers):

  • Half precision (binary16) - 11-bit significand, exponent range -14 to 15
  • Single precision (binary32) - 24-bit significand, exponent range -126 to 127
  • Double precision (binary64) - 53-bit significand, exponent range -1022 to 1023
  • Quadruple precision (binary128) - 113-bit significand, exponent range -16382 to 16383

How does this map onto C++ types, then? Generally the float uses single precision; thus, sizeof(float) = 4. Then double uses double precision (I believe that's the source of the name double), and long double may be either double or quadruple precision (it's quadruple on my system, but on 32-bit systems it may be double). I don't know of any compilers that offer half precision floating-points.

In summary, this is the usual:

  • sizeof(float) = 4
  • sizeof(double) = 8
  • sizeof(long double) = 8 or 16

As you mentioned - it largely depends upon the compiler and the platform. For this, check the ANSI standard, http://home.att.net/~jackklein/c/inttypes.html

Here is the one for the Microsoft compiler: Data Type Ranges.

You can use variables provided by libraries such as OpenGL, Qt, etc.

For example, Qt provides qint8 (guaranteed to be 8-bit on all platforms supported by Qt), qint16, qint32, qint64, quint8, quint16, quint32, quint64, etc.

On a 64-bit machine: 

int: 4
long: 8
long long: 8
void*: 8
size_t: 8

There are four types of integers based on size:

  • short integer: 2 byte
  • long integer: 4 byte
  • long long integer: 8 byte
  • integer: depends upon the compiler (16 bit, 32 bit, or 64 bit)

참고URL : https://stackoverflow.com/questions/589575/what-does-the-c-standard-state-the-size-of-int-long-type-to-be

반응형

'your programing' 카테고리의 다른 글

xkcd 스타일 그래프를 어떻게 만들 수 있습니까?  (0) 2020.09.30
C ++ 싱글 톤 디자인 패턴  (0) 2020.09.30
Git에서 특정 파일을 무시하는 방법  (0) 2020.09.30
다른 Python 파일을 가져 오는 방법은 무엇입니까?  (0) 2020.09.30
PECS (Producer Extends Consumer Super) 란 무엇입니까?  (0) 2020.09.30

'your programing'의 다른글

  • 현재글C ++ 표준은 int, long 유형의 크기를 무엇으로 지정합니까?

관련글

댓글

티스토리툴바