c++ - ترجمة - معنى كلمة عنوان بالانجليزي




ما الذي يحدده معيار C++ لحجم int ، من النوع الطويل؟ (16)

1) الجدول N1 في مقالة " المشاكل المنسية لتطوير برامج 64 بت "

2) " نموذج البيانات "

أنا أبحث عن معلومات مفصلة بشأن حجم أنواع C ++ الأساسية. أعلم أن ذلك يعتمد على البنية (16 بت ، 32 بت ، 64 بت) والمجمّع.

ولكن هل هناك أي معايير لـ C ++؟

أستخدم Visual Studio 2008 على بنية 32 بت. هذا ما أحصل عليه:

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

حاولت أن أجد ، دون نجاح كبير ، معلومات موثوق بها تفيد أحجام char ، short ، int ، long ، double ، float (وأنواع أخرى لم أفكر فيها) تحت بنيات ومجمّعات مختلفة.


إذا كنت بحاجة إلى أنواع حجم ثابت ، فاستخدم أنواعًا مثل uint32_t (عدد صحيح 32 بت stdint.h ) المعرّفة في stdint.h . يتم تحديدها في C99 .


بالنسبة لأرقام النقاط العائمة ، هناك معيار (IEEE754) : العوامات هي 32 بت ومضاعفة هي 64. هذا هو معيار للأجهزة ، وليس معيار C ++ ، بحيث يمكن للمتحكمين من الناحية النظرية تعريف العوامة ومضاعفة لبعض الأحجام الأخرى ، ولكن من الناحية العملية " لم أر أبدا الهندسة المعمارية التي تستخدم أي شيء مختلف.


بالنسبة لأنظمة 32 بت ، فإن المعيار "الواقعي" هو ILP32 - أي int و long و pointer ، جميعها بكميات 32 بت.

بالنسبة لأنظمة 64 بت ، يكون معيار "الأمر الواقع" الأساسي لـ Unix هو LP64 - long والمؤشر 64 بت (لكن int هو 32 بت). معيار 64 بت Windows هو LLP64 - long long ومؤشر 64 بت (ولكن long و int كليهما 32 بت).

في وقت واحد ، استخدمت بعض أنظمة يونكس منظمة ILP64.

لا يتم تشريع أي من هذه المعايير الفعلية بموجب المعيار C (ISO / IEC 9899: 1999) ، ولكن يُسمح بها جميعها.

sizeof(char) التعريف ، sizeof(char) هو 1 ، بغض النظر عن الاختبار في Perl تكوين البرنامج النصي.

لاحظ أن هناك آلات (Crays) حيث كان CHAR_BIT أكبر بكثير من 8. وهذا يعني ، IIRC ، أن sizeof(int) كان أيضاً 1 ، لأن كلا char و int كانت 32 بت.


عندما يتعلق الأمر ببناء أنواع مختلفة من الهندسة المعمارية ومختلف المجمعين فقط قم بتشغيل التعليمات البرمجية التالية في الهندسة المعمارية الخاصة بك مع المترجم الخاص بك لمعرفة ما الإخراج. يظهر أدناه بلدي Ubuntu 13.04 (رننج رينغتيل) 64 بت ز + 4.7.3 الإخراج. كما يرجى ملاحظة ما تم الإجابة عليه أدناه وهو السبب في طلب الإخراج على هذا النحو:

"هناك خمسة أنواع صحيحة قياسية موقعة: char موقعة و int قصير و int و long int و long long. في هذه القائمة ، يوفر كل نوع على الأقل مساحة تخزين كتلك التي تسبقه في القائمة."

#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

في الممارسة العملية لا يوجد شيء من هذا القبيل. يمكنك توقع std::size_t لتمثيل دوماً الحجم الصحيح الأصلي غير الموقعة على البنية الحالية. أي 16 بت أو 32 بت أو 64 بت.

ولكن فيما يتعلق بكل الأنواع الأخرى المدمجة ، فإنها تعتمد فعلاً على المترجم. فيما يلي مقتطفان مأخوذان من مسودة العمل الحالية لأحدث معايير C ++:

هناك خمسة أنواع صحيحة قياسية موقعة: char موقعة و int قصير و int و int طويلة و int طويلة طويلة. في هذه القائمة ، يوفر كل نوع مساحة تخزين على الأقل كتلك التي تسبقها في القائمة.

لكل نوع من أنواع الأعداد الصحيحة الموقعة القياسية ، يوجد نوع صحيح قياسي (ولكن مختلف) غير موقعة قياسي: char غير موقّع ، int قصير غير موقّع ، int int غير موقّع ، int int غير موقّع ، و int طويلة غير موقعة ، كل منها يشغل نفس المقدار من التخزين ولها نفس متطلبات التوافق.

إذا كنت تريد يمكنك بشكل ثابت (وقت التحويل البرمجي) تأكيد حجم هذه الأنواع الأساسية. وسوف ينبه الناس للتفكير في نقل التعليمات البرمجية الخاصة بك إذا تغيرت افتراضات sizeof.


كما ذكر ، يجب أن يعكس الحجم البنية الحالية. هل يمكن أن تأخذ ذروتها في limits.h إذا كنت تريد أن ترى كيف أن المترجم الحالي الخاص بك هو التعامل مع الأشياء.


لا يحدد معيار C ++ حجم الأنواع المتكاملة بالبايت ، ولكنه يحدد الحدود الدنيا التي يجب أن تكون قادرة على الاحتفاظ بها. يمكنك استنتاج الحجم الأدنى بالبتات من النطاق المطلوب. يمكنك استنتاج الحد الأدنى للحجم بالبايت من ذلك وقيمة الماكرو CHAR_BIT الذي يحدد عدد البتات في البايت (في جميع الأنظمة الأساسية غير الغامضة في 8 ، ولا يمكن أن يكون أقل من 8).

هناك قيد إضافي واحد لـ char هو أن حجمه دائمًا 1 بايت أو بتات CHAR_BIT (ومن هنا الاسم).

النطاقات الدنيا التي يتطلبها المعيار (الصفحة 22) هي:

ونطاقات نوع البيانات على MSDN :

  1. signed char : -127 إلى 127 (ملاحظة ، وليس -128 إلى 127 ؛ وهذا يستوعب منصات 1-تكملة و sign-and -itude)
  2. unsigned char : من 0 إلى 255
  3. char "عادي": نفس النطاق مثل signed char unsigned char أو unsigned char ، implementation-defined
  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) ).

يمكن العثور على النطاقات الفعلية الخاصة بالتنفيذ في رأس <limits.h> في C ، أو <climits> في C ++ (أو حتى أفضل ، std::numeric_limits في رأس <limits> std::numeric_limits <limits> ).

على سبيل المثال ، هذه هي الطريقة التي ستعثر بها على الحد الأقصى للنطاق 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();

هناك معيار محدد في وثائق المعايير المختلفة (ISO و ANSI و whatnot).

تحتوي 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 في std::numeric_limits . وهو يتضمن مجموعة كبيرة من الأوامر الأخرى التي يمكنك الاتصال بها لمعرفة الحدود المختلفة. يمكن استخدام هذا مع أي نوع تعسفي ينقل الحجم ، على سبيل المثال std :: streamsize.

تحتوي إجابة جون على أفضل وصف ، حيث أن تلك الإجابات مضمونة. بغض النظر عن النظام الأساسي الذي تستخدمه ، فهناك صفحة جيدة أخرى تدخل في تفاصيل أكثر عن عدد البتات التي يجب أن يحتوي عليها كل نوع: أنواع int ، والتي تم تحديدها في المعيار.

آمل أن يساعد هذا!


هناك معيار.

يتطلب معيار C90 ذلك

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

يتطلب معيار C99 ذلك

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

هنا مواصفات C99 . صفحة 22 تفاصيل أحجام أنواع متكاملة مختلفة.

فيما يلي أحجام نوع int (وحدات البت) للأنظمة الأساسية لـ Windows:

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_t لتكون 8 بت ، int16_t ليكون 16 بت ، إلخ.


يمكنك استخدام:

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

datatype = int ، long int إلخ. ستتمكن من رؤية الحجم لأي نوع بيانات تكتبه.


يُسمح لنا بتحديد مرادف للنوع حتى نتمكن من إنشاء "معيارنا" الخاص بنا.

على الجهاز الذي فيه sizeof (int) == 4 ، يمكننا تحديد:

typedef int int32;

int32 i;
int32 j;
...

لذلك عندما نقوم بنقل الشفرة إلى جهاز مختلف حيث يكون حجمها الفعلي هو 4 ، يمكننا فقط إعادة تعريف التواجد المفرد لـ int.

typedef long int int32;

int32 i;
int32 j;
...


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

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)

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.





c++-faq