c++ - সি++ বই




সি++ মান কি int int আকার, দীর্ঘ ধরনের হতে হবে? (16)

আমি মৌলিক C ++ প্রকারের আকার সম্পর্কিত বিস্তারিত তথ্য খুঁজছি। আমি জানি এটি স্থাপত্য (16 বিট, 32 বিট, 64 বিট) এবং কম্পাইলারের উপর নির্ভর করে।

কিন্তু সি ++ এর জন্য কোন মান আছে?

আমি একটি 32-বিট আর্কিটেকচারে ভিজ্যুয়াল স্টুডিও 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 (এবং অন্যান্য ধরনের আমি ভাবলাম না) এর মাপে নির্ভরযোগ্য তথ্য, অনেক সাফল্য ছাড়া, খুঁজে বের করার চেষ্টা করেছি।



32-বিট সিস্টেমগুলির জন্য, 'ডি ফ্যাক্টো' মান হল ILP32 - অর্থাৎ, int , long এবং পয়েন্টারটি সমস্ত 32-বিট পরিমাণ।

64-বিট সিস্টেমগুলির জন্য, প্রাথমিক ইউনিক্স 'ডি ফ্যাক্টো' মান LP64 - long এবং পয়েন্টার 64-বিট (তবে int 32-বিট)। উইন্ডোজ 64-বিট স্ট্যান্ডার্ড এলএলপি 64 - long long এবং পয়েন্টার 64-বিট (তবে long এবং int উভয় 32-বিট)।

এক সময়ে, কিছু ইউনিক্স সিস্টেম একটি ILP64 প্রতিষ্ঠান ব্যবহার করে।

এই সত্যিকারের কোনও মান সি সি স্ট্যান্ডার্ড (আইএসও / আইইসি 9899: 1999) দ্বারা বিন্যস্ত নয়, তবে এটির দ্বারা অনুমোদিত।

এবং, সংজ্ঞা অনুসারে, sizeof(char) 1 , পার্ল কনফিগার স্ক্রিপ্টে পরীক্ষার সত্ত্বেও।

উল্লেখ্য যে মেশিনগুলি ( CHAR_BIT ) ছিল যেখানে CHAR_BIT 8 এর চেয়ে অনেক বড় ছিল। এর অর্থ হল, আইআইআরসি, যে sizeof(int) 1 ছিল, কারন char এবং int উভয় 32-বিট ছিল।


অন্যরা যেমন উত্তর দিয়েছেন, "মানক" সবগুলি "বিস্তারিত সংজ্ঞায়িত" হিসাবে এবং "গৃহস্থালি" টাইপের "char_bis" প্রস্থে থাকে এবং শুধুমাত্র "গৃহস্থালি <= ছোট <= int <= দীর্ঘ < = দীর্ঘ লম্বা "(ফ্লোট এবং ডাবল IEEE ভাসমান বিন্দু মানগুলির সাথে অনেক সামঞ্জস্যপূর্ণ, এবং দীর্ঘ দ্বিগুণ সাধারণত দ্বিগুণ হিসাবে সমান - তবে আরো বর্তমান বাস্তবায়নে বড় হতে পারে)।

খুব নির্দিষ্ট এবং সঠিক মানের না থাকার কারনগুলির কারণ হল সি / সি ++ ভাষাগুলি বড় সংখ্যক হার্ডওয়্যার প্ল্যাটফর্মগুলিতে পোর্টেবল হওয়ার জন্য ডিজাইন করা হয়েছে - কম্পিউটার সিস্টেমগুলি সহ "গৃহস্থালি" শব্দ-আকারটি 4-বিট হতে পারে অথবা 7-বিট, অথবা "8- / 16- / 32-/ 64-বিট" কম্পিউটারের তুলনায় কিছু মান এমনকি হোম কম্পিউটার ব্যবহারকারীর কাছে উন্মুক্ত করা হয়। (এখানে শব্দ-আকার অর্থাত্ সিস্টেমটি সাধারণত কতগুলি বিট বিস্তৃত হয় তা বোঝায় - আবার, হোম কম্পিউটার ব্যবহারকারীরা আশা করে এটি 8-বিট নয়।)

যদি আপনি একটি নির্দিষ্ট সংখ্যক বিটগুলির প্রকৃতপক্ষে একটি বস্তুর (একটি অবিচ্ছেদ্য মান প্রতিনিধিত্বকারী বিটগুলির অনুভূতির অর্থে) প্রয়োজন হয় তবে বেশিরভাগ কম্পাইলারের এটি নির্দিষ্ট করার পদ্ধতি রয়েছে; কিন্তু এটি সাধারণত পোর্টেবল নয়, এমনকি আমে কোম্পানির তৈরি কম্পাইলারগুলির মধ্যেও বিভিন্ন প্ল্যাটফর্মের জন্য। কিছু মান এবং অনুশীলনগুলি (বিশেষত limits.h এবং এর মত) যথেষ্ট সাধারণ যে বেশিরভাগ কম্পাইলারগুলির নির্দিষ্ট মানের মানের জন্য সেরা-ফিট টাইপ নির্ধারণের জন্য সমর্থন থাকবে, কিন্তু ব্যবহৃত বিটগুলির সংখ্যা নয়। (অর্থাৎ, যদি আপনি জানেন যে আপনাকে 0 এবং 127 এর মধ্যে মানগুলি ধরে রাখা দরকার, তবে আপনার কম্পাইলারটি 8-বিটগুলির একটি "int8" প্রকারকে সমর্থন করে যা পূর্ণ পরিসরটি ধরে রাখার জন্য বড় অনুরোধ করবে, কিন্তু কোনটি এমন নয় "int7" টাইপ যা 7-বিটগুলির জন্য একটি সঠিক মিল হবে।)

দ্রষ্টব্য: অনেক UN * x উত্স প্যাকেজগুলি "./configure" স্ক্রিপ্ট ব্যবহার করে যা কম্পাইলার / সিস্টেমের ক্ষমতাগুলি অনুসন্ধান করবে এবং উপযুক্ত মেকফিল এবং config.h আউটপুট করবে। তারা কীভাবে কাজ করে এবং কীভাবে তারা কমলার / সিস্টেমের ক্ষমতাগুলি অনুসন্ধান করে এবং তাদের নেতৃত্ব অনুসরণ করে তা দেখতে কিছু স্ক্রিপ্ট পরীক্ষা করে দেখুন।


অ্যালেক্স বি থেকে সি ++ মানটি বাইটগুলিতে অবিচ্ছেদ্য ধরনের আকার উল্লেখ করে না, তবে এটি সর্বনিম্ন রেঞ্জগুলিকে নির্দিষ্ট করতে সক্ষম হতে পারে। আপনি প্রয়োজনীয় পরিসীমা থেকে বিট সর্বনিম্ন আকার নির্ণয় করতে পারেন। আপনি তার থেকে বাইটে ন্যূনতম আকার এবং CHAR_BIT ম্যাক্রোর মানটি বাইটের বিট সংখ্যা নির্ধারণ করতে পারেন (এটির মধ্যে 8 টি সবচেয়ে অস্পষ্ট প্ল্যাটফর্ম এবং এটি 8 এর কম হতে পারে না)।

গৃহস্থালিটির জন্য একটি অতিরিক্ত সীমাবদ্ধতা হল এটির আকার সর্বদা 1 বাইট, বা CHAR_BIT বিট (তাই নাম)।

মান দ্বারা ন্যূনতম রেঞ্জ প্রয়োজন (পৃষ্ঠা 22):

এবং MSDN এ ডেটা প্রকারের রেঞ্জগুলি:

স্বাক্ষরিত গৃহস্থালি: -127 থেকে 127 (নোট, 1২8 থেকে 127 পর্যন্ত; এইটি 1-এর-সম্পূরক প্ল্যাটফর্মগুলিকে ধারণ করে) অনির্ধারিত গৃহস্থালি: 0 থেকে 255 "প্লেইন" গৃহস্থালি: -127 থেকে 127 বা 0 থেকে 255 (ডিফল্ট গৃহস্থালি স্বাক্ষরতার উপর নির্ভর করে) স্বাক্ষরিত সংক্ষিপ্ত: -32767 থেকে 32767 স্বাক্ষরিত স্বল্প: 0 থেকে 65535 স্বাক্ষরিত int: -32767 থেকে 32767 স্বাক্ষরিত int: 0 থেকে 65535 স্বাক্ষর দীর্ঘ: -2147483647 থেকে 2147483647 অচেনা দীর্ঘ: 0 থেকে 4294967295 লম্বা লম্বা: -9223372036854775807 থেকে 9223372036854775807 অচেনা দীর্ঘ দীর্ঘ: 0 থেকে 18446744073709551615 একটি সি ++ (বা সি) বাস্তবায়ন কোনও আকারের বাইট আকারের (টাইপ) কোন আকারের আকার নির্ধারণ করতে পারে, যতক্ষণ না

এক্সপ্রেশন sizeof (type) * CHAR_BIT প্রয়োজনীয় রেঞ্জ ধারণ করার জন্য যথেষ্ট বিটগুলির মূল্যায়ন করে এবং টাইপের ক্রম এখনও বৈধ (উদাহরণস্বরূপ sizeof (int) <= sizeof (long))। বাস্তব বাস্তবায়ন-নির্দিষ্ট রেঞ্জগুলি হে, বা C ++ (অথবা এমনকি আরও ভাল, শিরোনামযুক্ত std :: শিরোনাম_সংখ্যার শিরোনামে) শিরোনামের মধ্যে পাওয়া যেতে পারে।

উদাহরণস্বরূপ, এইভাবে আপনি int- এর জন্য সর্বাধিক পরিসর পাবেন:

সি:

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

সি ++:

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

এটি সঠিক, তবে, আপনি ঠিক বলেছিলেন যে: গৃহস্থালি: 1 বাইট ছোট: 2 বাইট int: 4 বাইট লম্বা: 4 বাইট ফ্লোট: 4 বাইট দ্বিগুণ: 8 বাইট

কারণ 32 বিট আর্কিটেকচারগুলি এখনও ডিফল্ট এবং সর্বাধিক ব্যবহৃত, এবং স্মৃতিগুলি কম উপলব্ধ হওয়ার পূর্বে 32-বিট দিনগুলি থেকে এই স্ট্যান্ডার্ড মাপগুলি রেখেছে এবং পিছনে সামঞ্জস্য এবং মানসম্মতকরণের জন্য এটি একই। এমনকি 64 বিট সিস্টেম এই ব্যবহার এবং ঝোঁক / পরিবর্তন আছে ঝোঁক। আরও তথ্যের জন্য এই রেফারেন্স দয়া করে:

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


আমরা টাইপের জন্য একটি প্রতিশব্দ সংজ্ঞায়িত করার অনুমতি দেওয়া হয় যাতে আমরা আমাদের নিজস্ব "মানক" তৈরি করতে পারি।

একটি মেশিনে sizeof (int) == 4, আমরা সংজ্ঞায়িত করতে পারি:

typedef int int32;

int32 i;
int32 j;
...

তাই যখন আমরা কোডটিকে অন্য মেশিনে স্থানান্তরিত করি যেখানে প্রকৃতপক্ষে দীর্ঘ int এর আকার 4 হয়, আমরা কেবল int এর একক ঘটনার পুনর্বিবেচনা করতে পারি।

typedef long int int32;

int32 i;
int32 j;
...

আমি লক্ষ্য করেছি যে এখানে অন্য সকল উত্তরগুলি প্রায় একচেটিয়াভাবে অবিচ্ছেদ্য প্রকারের দিকে দৃষ্টি নিবদ্ধ করেছে, যখন প্রশ্নকারীটি ভাসমান-পয়েন্ট সম্পর্কেও জিজ্ঞাসা করেছেন।

আমি মনে করি না সি ++ মানটি এটির প্রয়োজন, কিন্তু সবচেয়ে সাধারণ প্ল্যাটফর্মগুলির জন্য কম্পাইলারগুলি এই দিনগুলি সাধারণত তাদের ভাসমান-বিন্দু সংখ্যার জন্য IEEE754 মানকে অনুসরণ করে। এই মানটি চার ধরণের বাইনারি ভাসমান-বিন্দু নির্দিষ্ট করে (পাশাপাশি কিছু বিসিডি ফরম্যাট, যা আমি সি ++ কম্পাইলারগুলির জন্য সমর্থন দেখিনি):

  • অর্ধেক স্পষ্টতা (বাইনারি 16) - 11-বিট তাত্পর্য, সূচক পরিসীমা -14 থেকে 15
  • একক স্পষ্টতা (বাইনারি 32) - ২4-বিট তাত্পর্য, সূচক পরিসীমা -126 থেকে 127
  • ডাবল স্পষ্টতা (বাইনারি 64) - 53-বিট তাত্পর্য, এক্সপোনের পরিসর -10২২ থেকে 1023
  • চতুর্ভুজ নির্ভুলতা (বাইনারি 1২8) - 113-বিট তাত্পর্য, সূচক পরিসর -1638২ থেকে 16383

কিভাবে এই মানচিত্র সি ++ ধরনের সম্মুখের তারপর? সাধারণত floatএকক স্পষ্টতা ব্যবহার করে; এইভাবে sizeof(float) = 4,। তারপর doubleডবল নির্ভুলতা ব্যবহার করে (আমি বিশ্বাস করি যে এটির উৎসের উৎস double), এবং long doubleএটি দ্বিগুণ বা চতুর্ভুজ নির্ভুলতা হতে পারে (এটি আমার সিস্টেমে চতুর্ভুজ, কিন্তু 32-বিট সিস্টেমে এটি দ্বিগুণ হতে পারে)। আমি অর্ধেক স্পষ্টতা ভাসমান-পয়েন্ট প্রস্তাব যে কোন কম্পাইলার জানি না।

সংক্ষিপ্তভাবে, এটি স্বাভাবিক:

  • sizeof(float) = 4
  • sizeof(double) = 8
  • sizeof(long double) = 8 বা 16

তুমি ব্যবহার করতে পার:

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

datatype = int , long int ইত্যাদি। আপনি যে টাইপ টাইপ টাইপ করবেন তার জন্য আপনি আকার দেখতে পারবেন।


না, টাইপ মাপের জন্য কোন মান। স্ট্যান্ডার্ড শুধুমাত্র প্রয়োজন যে:

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

যদি আপনি একটি নির্দিষ্ট মাপের ভেরিয়েবল চান তবে আপনি এটি করতে পারেন এমন সেরা জিনিস হল ম্যাক্রোগুলি ব্যবহার করা:

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

তারপর আপনি আপনার ভেরিয়েবল সংজ্ঞায়িত করতে ওয়ার্ড ব্যবহার করতে পারেন। এটা আমি পছন্দ করি না কিন্তু এটি সবচেয়ে পোর্টেবল উপায়।


ভাসমান বিন্দু সংখ্যার জন্য একটি স্ট্যান্ডার্ড (IEEE754) রয়েছে : ভাস্টগুলি 32 বিট এবং ডাবলস 64. এটি একটি হার্ডওয়্যার মানক, সি ++ মান নয়, তাই কম্পাইলার তাত্ত্বিকভাবে তাত্পর্যপূর্ণভাবে অন্য কোন আকারের ফ্ল্যাট এবং দ্বিগুণ সংজ্ঞায়িত করতে পারে তবে অনুশীলনে আমি ' কিছু ভিন্ন ব্যবহৃত যে একটি আর্কিটেকচার দেখা যায় না।


মান আছে।

C90 মান যে প্রয়োজন

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

C99 মান যে প্রয়োজন

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

এখানে C99 বিশেষ উল্লেখ । পৃষ্ঠা 22 বিভিন্ন অবিচ্ছেদ্য ধরনের বিবরণ মাপ।

এখানে উইন্ডোজ প্ল্যাটফর্মের জন্য int টাইপ মাপ (বিট):

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

আপনি যদি পোর্টেবিলিটির সাথে উদ্বিগ্ন হন, অথবা আপনি চান যে আকারটি আকারকে প্রতিফলিত করে তবে আপনি <inttypes.h> দেখতে পারেন <inttypes.h> , যেখানে নিম্নলিখিত ম্যাক্রো উপলব্ধ রয়েছে:

int8_t
int16_t
int32_t
int64_t

int8_t 8 বিট হতে নিশ্চিত, এবং int16_t 16 বিট, ইত্যাদি নিশ্চিত করা হয়।


যদি আপনার নির্দিষ্ট আকারের প্রকারের প্রয়োজন হয়, তবে stdint.h- তে সংজ্ঞায়িত uint32_t (অনির্ধারিত পূর্ণসংখ্যা 32 বিট) -এর মতো প্রকার ব্যবহার করুন। তারা C99 নির্দিষ্ট করা হয়।


যদি আপনি একটি বিশুদ্ধ C ++ সমাধানতে আগ্রহী হন তবে আমি তাদের বিট আকারের উপর ভিত্তি করে কম্পাইল সময়গুলিতে প্রকারগুলি সংজ্ঞায়িত করতে টেমপ্লেট এবং কেবলমাত্র সি ++ মানক কোড ব্যবহার করেছি। এই সমাধান কম্পাইলার জুড়ে পোর্টেবল করা।

পিছনে ধারণাটি খুবই সহজ: গৃহস্থালি, int, সংক্ষিপ্ত, দীর্ঘ, দীর্ঘ দীর্ঘ (স্বাক্ষরিত এবং স্বাক্ষরিত সংস্করণ) এবং তালিকা স্ক্যান এবং সংখ্যাসূচক_লিমিটস টেমপ্লেট ব্যবহার করে একটি তালিকা তৈরি করুন প্রদত্ত আকারের সাথে টাইপ নির্বাচন করুন।

এই হেডার সহ 8 টি স্ট্যাড টাইপ :: int8, stdtype :: int16, stdtype :: int32, stdtype :: int64, stdtype :: uint8, stdtype :: uint16, stdtype :: uint32, stdtype :: uint64।

যদি কিছু প্রকারকে প্রতিনিধিত্ব করা যায় না তবে এটি শিরোনামে stdtype :: null_type এও মূল্যায়ন করা হবে।

নীচের কোডটি ওয়ারেন্টি ছাড়াই দেওয়া হয়েছে, দয়া করে এটি চেক করুন।
আমি ম্যাপগ্র্যাফর্মিং এ নতুন, এই কোড সম্পাদনা এবং সংশোধন করতে বিনা দ্বিধায়।
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;

}

সি ++ স্ট্যান্ডার্ড এটি ভালো লেগেছে:

3.9.1, §2:

পাঁচটি স্বাক্ষরযুক্ত পূর্ণসংখ্যা রয়েছে: "স্বাক্ষরিত গৃহস্থালি", "স্বল্প int", "int", "দীর্ঘ int", এবং "দীর্ঘ দীর্ঘ int"। এই তালিকায়, প্রতিটি ধরন তালিকাতে পূর্ববর্তী হিসাবে অন্তত যত বেশি সঞ্চয়স্থান সরবরাহ করে। সামান্য ইটগুলিতে প্রাকৃতিক আকারের নির্মান পরিবেশের প্রস্তাবিত প্রাকৃতিক আকার রয়েছে (44); অন্যান্য স্বাক্ষর পূর্ণসংখ্যা ধরনের বিশেষ প্রয়োজন মেটাতে দেওয়া হয়।

(44) অর্থাৎ, INT_MIN এবং INT_MAX এর সীমার মধ্যে যেকোন মান রয়েছে যা শিরোনাম <climits> নির্ধারিত

উপসংহার: এটি নির্ভর করে আপনি কোন স্থাপত্যের উপর কাজ করছেন। অন্য কোন ধারণা মিথ্যা।


আকারের উপর ভিত্তি করে চার ধরণের পূর্ণসংখ্যা রয়েছে:

  • সংক্ষিপ্ত পূর্ণসংখ্যা: 2 বাইট
  • দীর্ঘ পূর্ণসংখ্যা: 4 বাইট
  • দীর্ঘ দীর্ঘ পূর্ণসংখ্যা: 8 বাইট
  • পূর্ণসংখ্যা: কম্পাইলার উপর নির্ভর করে (16 বিট, 32 বিট, বা 64 বিট)

আপনি OpenGL , Qt , ইত্যাদি লাইব্রেরিগুলি দ্বারা সরবরাহিত ভেরিয়েবলগুলি ব্যবহার করতে পারেন ।

উদাহরণস্বরূপ, QT8 provides করে (qt দ্বারা সমর্থিত সমস্ত প্ল্যাটফর্মগুলিতে 8-বিট নিশ্চিত), qint16, qint32, qint64, quint8, quint16, quint32, quint64 ইত্যাদি প্রদান করে।


আপনি যেমন উল্লেখ করেছেন - এটি মূলত কম্পাইলার এবং প্ল্যাটফর্মের উপর নির্ভর করে। এর জন্য, ANSI মানকটি চেক করুন, http://home.att.net/~jackklein/c/inttypes.html

এখানে মাইক্রোসফ্ট কম্পাইলারের জন্য একটি: ডেটা প্রকারের রেঞ্জ





c++-faq