সিতে বড় এন্ডিয়ানকে সামান্য এন্ডিয়ান রূপান্তর করুন [প্রদত্ত ফানক ব্যবহার না করে] [বন্ধ]

Question

বড় এন্ডিয়ানকে সি-তে ছোট এন্ডিয়ান রূপান্তর করতে আমার একটি ফাংশন লিখতে হবে আমি কোনও লাইব্রেরি ফাংশন ব্যবহার করতে পারি না।

Comments

একটি 16 বিট মান? 32 বিটের মান? ভাসা? একটি অ্যারের?

— জন নোয়েলার

সময় সম্ভবত একটি উত্তর চয়ন করার জন্য?

— অনিকেত ইঙ্গে

পুনরায় খুলতে ভোট। সি ++ এর জন্য স্ট্যাকওভারফ্লো / প্রশ্নগুলি 1015252/… হিসাবে একই । আমরা কেবল এটি পরিষ্কার করার জন্য সম্পাদনা করতে পারি।

— সিরো সান্তিলি 郝海东 冠状 病 六四 事件

Answer 1

আপনার যা প্রয়োজন তা ধরে নেওয়া একটি সাধারণ বাইট অদলবদল, এরকম কিছু চেষ্টা করুন

স্বাক্ষরযুক্ত 16 বিট রূপান্তর:

swapped = (num>>8) | (num<<8);

স্বাক্ষরযুক্ত 32-বিট রূপান্তর:

swapped = ((num>>24)&0xff) | // move byte 3 to byte 0
                    ((num<<8)&0xff0000) | // move byte 1 to byte 2
                    ((num>>8)&0xff00) | // move byte 2 to byte 1
                    ((num<<24)&0xff000000); // byte 0 to byte 3

এটি 1234 থেকে 4321 পজিশন থেকে বাইট অর্ডারগুলি অদলবদল করে। যদি আপনার ইনপুটটি থাকে তবে 0xdeadbeefএকটি 32-বিট এন্ডিয়ান স্বাপের আউটপুট থাকতে পারে 0xefbeadde।

উপরের কোডটি যাদু সংখ্যার পরিবর্তে ম্যাক্রো বা কমপক্ষে ধ্রুবক দিয়ে পরিষ্কার করা উচিত, তবে আশা করি এটি যেমনটি সহায়তা করে

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

Comments

প্ল্যাটফর্ম / হার্ডওয়্যার-নির্দিষ্ট পদ্ধতি উল্লেখ করার জন্য +1। প্রোগ্রামগুলি সর্বদা কিছু হার্ডওয়্যারে চালিত হয় এবং হার্ডওয়্যার বৈশিষ্ট্যগুলি সর্বদা দ্রুত হয়।

— ইওনিল

যদি 16 বিট রূপান্তর হিসাবে করা হয় ((num & 0xff) >> 8) | (num << 8), জিসিসি 4.8.3 একটি একক rolনির্দেশ উত্পন্ন করে । এবং যদি 32 বিট রূপান্তর হিসাবে লেখা হয় তবে ((num & 0xff000000) >> 24) | ((num & 0x00ff0000) >> 8) | ((num & 0x0000ff00) << 8) | (num << 24)একই সংকলক একটি একক bswapনির্দেশ উত্পন্ন করে ।

— ব্যবহারকারী 666412

আমি জানি না এটি কতটা দক্ষ তবে আমি এই জাতীয় বিটফিল্ডের সাথে বাইট ক্রমটি অদলবদল করেছি: struct byte_t reverse(struct byte_t b) { struct byte_t rev; rev.ba = b.bh; rev.bb = b.bg; rev.bc = b.bf; rev.bd = b.be; rev.be = b.bd; rev.bf = b.bc; rev.bg = b.bb; rev.bh = b.ba; return rev;}যেখানে এটি 8 টি ক্ষেত্র 1 বিট প্রতি বিটফিল্ড। তবে আমি নিশ্চিত নই যে অন্যান্য পরামর্শগুলির মতো দ্রুত if ইনটসের জন্য union { int i; byte_t[sizeof(int)]; }পূর্ণসংখ্যায় বাইট বাই বিপরীত করতে ব্যবহার করুন ।

— ইলিয়ান জাপ্রিয়ানভ

আমি মনে করি এক্সপ্রেশনটি অবশ্যই হবে: (সংখ্যা >> 8) | (সংখ্যা << 8) বাইট ক্রমটি বিপরীত করতে এবং নয়: ((সংখ্যা এবং 0xff) >> 8) | (সংখ্যা << 8), ভুল উদাহরণটি লো-বাইটে শূন্য হয়।

— jscom

@ ইলিয়ানজাপ্রায়ানভ সম্ভবত স্পষ্টতার জন্য +1 করেছেন তবে সি তে বিটফিল্ড ব্যবহার করা সম্ভবত এটি করার সবচেয়ে কম দক্ষ উপায়।

— sherrellbc

Answer 2

অন্তর্ভুক্ত দ্বারা:

#include <byteswap.h>

আপনি মেশিন-নির্ভর বাইট-সোয়াপিং ফাংশনগুলির একটি অনুকূলিত সংস্করণ পেতে পারেন। তারপরে, আপনি সহজেই নিম্নলিখিত ফাংশনগুলি ব্যবহার করতে পারেন:

__bswap_32 (uint32_t input)

বা

__bswap_16 (uint16_t input)

Comments

আপনার উত্তরের জন্য ধন্যবাদ, তবে আমি কোনও লাইব্রেরির ফাংশন ব্যবহার করতে পারি না

— মার্ক র্যানসোম

পড়া উচিত #include <byteswap.h>, .h ফাইল নিজেই মন্তব্য দেখুন। এই পোস্টে সহায়ক তথ্য রয়েছে তাই আমি লিপ ফাংশনটি ব্যবহার না করার জন্য ওপি প্রয়োজনীয়তা উপেক্ষা করে লেখক সত্ত্বেও আমি ভোট দিয়েছি।

— এলি রোজক্রাফ্ট

আসলে, __bswap_32 / __ bswap_16 ফাংশন আসলে ম্যাক্রোগুলি এবং লাইব্রেরি ফাংশন নয়, আপ-ভোট দেওয়ার আরও একটি কারণ।

— এলি রোজক্রাফ্ট

আমার বোধগম্যতা হ'ল এই শিরোনামটি সমস্ত আর্কিটেকচারের সমস্ত অপারেটিং সিস্টেমের জন্য উপস্থিত থাকার নিশ্চয়তা নেই। এন্ডিয়ান সমস্যাগুলি মোকাবিলার জন্য এখনও আমার কাছে বহনযোগ্য উপায় খুঁজে পাওয়া যায়নি।

— এডওয়ার্ড ফ্যালক

উইন্ডোজে উপস্থিত নেই - কমপক্ষে যখন লিনাক্স থেকে

— মিংডু

Answer 3

#include <stdint.h>


//! Byte swap unsigned short
uint16_t swap_uint16( uint16_t val ) 
{
    return (val << 8) | (val >> 8 );
}

//! Byte swap short
int16_t swap_int16( int16_t val ) 
{
    return (val << 8) | ((val >> 8) & 0xFF);
}

//! Byte swap unsigned int
uint32_t swap_uint32( uint32_t val )
{
    val = ((val << 8) & 0xFF00FF00 ) | ((val >> 8) & 0xFF00FF ); 
    return (val << 16) | (val >> 16);
}

//! Byte swap int
int32_t swap_int32( int32_t val )
{
    val = ((val << 8) & 0xFF00FF00) | ((val >> 8) & 0xFF00FF ); 
    return (val << 16) | ((val >> 16) & 0xFFFF);
}

আপডেট : 64 বিট বাইট অদলবদল করা হয়েছে

int64_t swap_int64( int64_t val )
{
    val = ((val << 8) & 0xFF00FF00FF00FF00ULL ) | ((val >> 8) & 0x00FF00FF00FF00FFULL );
    val = ((val << 16) & 0xFFFF0000FFFF0000ULL ) | ((val >> 16) & 0x0000FFFF0000FFFFULL );
    return (val << 32) | ((val >> 32) & 0xFFFFFFFFULL);
}

uint64_t swap_uint64( uint64_t val )
{
    val = ((val << 8) & 0xFF00FF00FF00FF00ULL ) | ((val >> 8) & 0x00FF00FF00FF00FFULL );
    val = ((val << 16) & 0xFFFF0000FFFF0000ULL ) | ((val >> 16) & 0x0000FFFF0000FFFFULL );
    return (val << 32) | (val >> 32);
}

Comments

জন্য int32_tএবং int64_tরূপগুলো, এর মাস্কিং পিছনে যুক্তি কি ... & 0xFFFFএবং ... & 0xFFFFFFFFULL? এখানে সাইন-এক্সটেনশন নিয়ে কিছু চলছে যা আমি দেখছি না? এছাড়াও, কেন swap_int64ফিরছে uint64_t? তা কি হওয়া উচিত নয় int64_t?

— বিগুডার 14

Swint_int64 একটি uint64 ফেরত আসলে একটি ত্রুটি। স্বাক্ষরযুক্ত মান মান সহ মাস্কিং সত্যই সাইন অপসারণ করা হয়। ডান স্থানান্তরিত করা বাম দিকে চিহ্ন বিট ইনজেকশন। আমরা কেবল স্বাক্ষরবিহীন ইন্ট সোয়াপিং অপারেশনটি কল করে এড়াতে পারি could

— chmike

ধন্যবাদ আপনি swap_int64নিজের উত্তরের জন্য রিটার্ন মানটির ধরণটি পরিবর্তন করতে চাইতে পারেন । সহায়ক উত্তরের জন্য +1, বিটিডাব্লু!

— বিগুডার

বিটওয়াইজ এবং মান এন্ডিয়ান নির্ভর?

— মারকাসজে 21

LLঅপ্রয়োজনীয় হয় (u)swap_uint64()অনেক একটি মত Lএ প্রয়োজন হয় না (u)swap_uint32()। Uপ্রয়োজন হয় না uswap_uint64()অনেক মত Uমধ্যে প্রয়োজন হয় নাuswap_uint32()

— chux - পুনর্বহাল মনিকা

Answer 4

এখানে একটি মোটামুটি জেনেরিক সংস্করণ; আমি এটি সংকলন করি নি, সুতরাং সম্ভবত টাইপস রয়েছে, তবে আপনার ধারণাটি পাওয়া উচিত,

void SwapBytes(void *pv, size_t n)
{
    assert(n > 0);

    char *p = pv;
    size_t lo, hi;
    for(lo=0, hi=n-1; hi>lo; lo++, hi--)
    {
        char tmp=p[lo];
        p[lo] = p[hi];
        p[hi] = tmp;
    }
}
#define SWAP(x) SwapBytes(&x, sizeof(x));

নোট: এটিগতি বা স্থানের জন্য অনুকূলিত নয় । এটি পরিষ্কার (ডিবাগ করা সহজ) এবং বহনযোগ্য to

আপডেট 2018-04-04 কমেন্টার @chux দ্বারা চিহ্নিত হিসাবে n == 0 এর অবৈধ কেস ফাঁদে ফেলার জন্য দৃ as়তা () যোগ করেছে।

Comments

আপনি আরও ভাল পারফরম্যান্সের জন্য xorSwap ব্যবহার করতে পারেন। এই জেনেরিক সংস্করণটিকে সমস্ত আকারের নির্দিষ্ট আকারের চেয়ে বেশি পছন্দ করুন ...

আমি এটি পরীক্ষা করেছি, এটি দেখা যাচ্ছে যে এটি এক্স 86 এর চেয়ে ... এক্সওর পরিবর্তনের চেয়ে দ্রুত। stackoverflow.com/questions/3128095/...

@ নুনস - খুব সাধারণ কোডের একটি সুবিধা হ'ল সংকলক অপটিমাইজার কখনও কখনও এটি খুব দ্রুত তৈরি করতে পারে।

— মাইকেল জে

@ মিশেলজে ওটিওএইচ, চিমিকের উত্তরের উপরের 32 বিট সংস্করণটি bswapঅপ্টিমাইজেশান সক্ষম সহ একটি শালীন X86 সংকলক দ্বারা একটি নির্দেশে সংকলিত হয়েছে । আকারের পরামিতি সহ এই সংস্করণটি এটি করতে পারে নি।

— Alnitak

@ অ্যালনিটাক - যেমনটি আমি বলেছি, আমি আমার কোডটিকে অনুকূল করে তুলতে কোন প্রচেষ্টা করিনি। যখন ব্যবহারকারী অনুভব করলেন যে কোডটি খুব দ্রুত ছড়িয়েছে (এক ক্ষেত্রে) আমি কেবলমাত্র সাধারণ ধারণাটি উল্লেখ করেছি যে সাধারণ কোডটি প্রায়শই একটি সংকলক দ্বারা উচ্চতর অনুকূলিতকরণ করা যায়। আমার কোড বিস্তৃত বিভিন্ন ক্ষেত্রে কাজ করে এবং এটি বোঝা বেশ সহজ এবং এভাবে ডিবাগ করা সহজ। যে আমার উদ্দেশ্য পূরণ।

— মাইকেল জে

Answer 5

আপনার যদি ম্যাক্রোগুলির প্রয়োজন হয় (যেমন এম্বেডেড সিস্টেম):

#define SWAP_UINT16(x) (((x) >> 8) | ((x) << 8))
#define SWAP_UINT32(x) (((x) >> 24) | (((x) & 0x00FF0000) >> 8) | (((x) & 0x0000FF00) << 8) | ((x) << 24))

Comments

এই ম্যাক্রোগুলি ভাল, তবে (x) >> 24) ব্যর্থ হবে যখন একটি স্বাক্ষরিত পূর্ণসংখ্যা 0x80000000 এবং 0xffffffff এর মধ্যে হয় is বিটওয়াইস এবং এখানে ব্যবহার করা ভাল ধারণা। দ্রষ্টব্য: ((x) << 24) পুরোপুরি নিরাপদ। (x) >> 8) উচ্চ 16 বিট ননজারো হলে (বা স্বাক্ষরিত 16-বিট মান সরবরাহ করা হয়) ব্যর্থও হবে।

@ প্যাকম্যান - এই ম্যাক্রোগুলি কেবল স্বাক্ষরবিহীন পূর্ণসংখ্যার অদলবদল করার জন্য ব্যবহার করার উদ্দেশ্যে are এই কারণেই UINTতাদের নামে রয়েছে।

— kol

হ্যাঁ, সত্য, আওয়াজের জন্য দুঃখিত। কোনও টাইপকাস্ট এম্বেড করা ভাল না?

Answer 6

সম্পাদনা করুন: এগুলি গ্রন্থাগার ফাংশন। তাদের অনুসরণ করা এটি করার ম্যানুয়াল উপায়।

__Byteswap_ushort, __bywap_ulong, এবং __byteswap_uint64 সম্পর্কে অজানা লোকের সংখ্যা শুনে আমি একেবারে হতবাক । নিশ্চিত যে এগুলি ভিজ্যুয়াল সি ++ নির্দিষ্ট, তবে তারা x86 / IA-64 আর্কিটেকচারের কিছু সুস্বাদু কোডটি সংকলন করে। :)

এই পৃষ্ঠাটি থেকে টানাbswap নির্দেশের একটি স্পষ্ট ব্যবহার এখানে । নোট করুন যে উপরের অভ্যন্তরীণ ফর্মটি সর্বদা এর চেয়ে দ্রুততর হবে , আমি কেবল এটি লাইব্রেরির রুটিন ছাড়া উত্তর দেওয়ার জন্য যুক্ত করেছি।

uint32 cq_ntohl(uint32 a) {
    __asm{
        mov eax, a;
        bswap eax; 
    }
}

Comments

একটি সি প্রশ্নের জন্য, আপনি ভিজ্যুয়াল সি ++ এর সাথে নির্দিষ্ট কিছু প্রস্তাব দিচ্ছেন?

— অলোক সিংহল

@ অলোক: ভিজ্যুয়াল সি ++ মাইক্রোসফ্টের একটি পণ্য। এটি সি কোড সংকলনের জন্য ঠিক কাজ করে। :)

— স্যাম হারওয়েল

আপনি কেন বিস্মিত হন যে বাইটস্যাপিংয়ের মাইক্রোসফ্ট-নির্দিষ্ট প্রয়োগগুলি সম্পর্কে অনেক লোক সচেতন নয়?

— স্বপ্ন

শীতল, এটি এমন কোনও বদ্ধ উত্স পণ্য বিকাশকারী যার পক্ষে বহনযোগ্য বা মান সম্মত হওয়ার প্রয়োজন হয় না এমন বিকাশের জন্য এটি ভাল তথ্য।

— স্যাম পোস্ট

@ অলোক, ওপি সংকলক | ওএসের কথা উল্লেখ করেনি। কোনও নির্দিষ্ট সরঞ্জামের সাথে তার অভিজ্ঞতা অনুযায়ী কোনও ব্যক্তিকে উত্তর দেওয়ার অনুমতি দেওয়া হয়।

— অনিকেত ইনজে

Answer 7

রসিকতা হিসাবে:

#include <stdio.h>

int main (int argc, char *argv[])
{
    size_t sizeofInt = sizeof (int);
    int i;

    union
    {
        int x;
        char c[sizeof (int)];
    } original, swapped;

    original.x = 0x12345678;

    for (i = 0; i < sizeofInt; i++)
        swapped.c[sizeofInt - i - 1] = original.c[i];

    fprintf (stderr, "%x\n", swapped.x);

    return 0;
}

Comments

হা হা হা হা হা. হাহাহাহা। হা। হা? (কী কৌতুক?)

আপনি কিছু উইন্ডোজ উত্স সংগ্রহস্থল থেকে এটি টানছেন? :)

— hochl

নোডেজ এই কৌশলটি ব্যবহার করে! github.com/nodejs/node/blob/…

— জাস্টিন মোসার

ব্যবহার জানতে আগ্রহী int i, size_t sizeofIntএবং উভয়ের জন্য একই ধরনের।

— chux -

Answer 8

এখানে এসএসএসই 3 নির্দেশনাটি শুশবকে এর ইনটেল অভ্যন্তরীণ ব্যবহার করে এমন এক উপায় রয়েছে যা ধরে নিই যে আপনার 4 টির একাধিক রয়েছে int:

unsigned int *bswap(unsigned int *destination, unsigned int *source, int length) {
    int i;
    __m128i mask = _mm_set_epi8(12, 13, 14, 15, 8, 9, 10, 11, 4, 5, 6, 7, 0, 1, 2, 3);
    for (i = 0; i < length; i += 4) {
        _mm_storeu_si128((__m128i *)&destination[i],
        _mm_shuffle_epi8(_mm_loadu_si128((__m128i *)&source[i]), mask));
    }
    return destination;
}

Answer 9

এই কাজটি কি দ্রুত হবে?

 uint32_t swapped, result;

((byte*)&swapped)[0] = ((byte*)&result)[3];
((byte*)&swapped)[1] = ((byte*)&result)[2];
((byte*)&swapped)[2] = ((byte*)&result)[1];
((byte*)&swapped)[3] = ((byte*)&result)[0];

Comments

আমি মনে করি আপনি বোঝাতে চেয়েছেন char, না byte।

— ড্রিমলাক্স

এই কৌশলটি ব্যবহার করে, আপনার তুলনায় বেশিরভাগ ভোটের সাথে সমাধানটি সমতুল্য এবং সবচেয়ে দক্ষ এবং পোর্টেবল। তবে আমি প্রস্তাবিত সমাধানটির (দ্বিতীয় সর্বাধিক ভোট) কম অপারেশন প্রয়োজন এবং আরও দক্ষ হওয়া উচিত।

— chmike

Answer 10

এখানে আমি ব্যবহার করছি এমন কোনও ফাংশন - পরীক্ষিত এবং কোনও বুনিয়াদি ডেটা ধরণের উপর কাজ করে:

//  SwapBytes.h
//
//  Function to perform in-place endian conversion of basic types
//
//  Usage:
//
//    double d;
//    SwapBytes(&d, sizeof(d));
//

inline void SwapBytes(void *source, int size)
{
    typedef unsigned char TwoBytes[2];
    typedef unsigned char FourBytes[4];
    typedef unsigned char EightBytes[8];

    unsigned char temp;

    if(size == 2)
    {
        TwoBytes *src = (TwoBytes *)source;
        temp = (*src)[0];
        (*src)[0] = (*src)[1];
        (*src)[1] = temp;

        return;
    }

    if(size == 4)
    {
        FourBytes *src = (FourBytes *)source;
        temp = (*src)[0];
        (*src)[0] = (*src)[3];
        (*src)[3] = temp;

        temp = (*src)[1];
        (*src)[1] = (*src)[2];
        (*src)[2] = temp;

        return;
    }

    if(size == 8)
    {
        EightBytes *src = (EightBytes *)source;
        temp = (*src)[0];
        (*src)[0] = (*src)[7];
        (*src)[7] = temp;

        temp = (*src)[1];
        (*src)[1] = (*src)[6];
        (*src)[6] = temp;

        temp = (*src)[2];
        (*src)[2] = (*src)[5];
        (*src)[5] = temp;

        temp = (*src)[3];
        (*src)[3] = (*src)[4];
        (*src)[4] = temp;

        return;
    }

}

Comments

কোড একটি খুব যুক্তিসঙ্গত অনুমানের উপর নির্ভর করে: sourceপ্রয়োজনীয় হিসাবে প্রান্তিক করা হয় - তবুও যদি এই অনুমানটি ধরে না রাখে, কোডটি ইউবি।

— chux -

Answer 11

সম্পাদনা: এই ফাংশনটি কেবলমাত্র 16 বিট শব্দের প্রান্তিককরণের পরিবর্তন করে। ইউটিএফ -16 / ইউসিএস -2 এনকোডিংয়ের জন্য প্রায়শই প্রয়োজনীয় একটি ক্রিয়াকলাপ। সম্পাদনা সমাপ্তি।

আপনি যদি কোনও মেমরির ব্লকের অন্তর্নিহিততা পরিবর্তন করতে চান তবে আপনি আমার নির্লজ্জভাবে দ্রুত পদ্ধতির ব্যবহার করতে পারেন। আপনার মেমরি অ্যারের একটি আকার হওয়া উচিত যা 8 এর একাধিক।

#include <stddef.h>
#include <limits.h>
#include <stdint.h>

void ChangeMemEndianness(uint64_t *mem, size_t size) 
{
uint64_t m1 = 0xFF00FF00FF00FF00ULL, m2 = m1 >> CHAR_BIT;

size = (size + (sizeof (uint64_t) - 1)) / sizeof (uint64_t);
for(; size; size--, mem++)
  *mem = ((*mem & m1) >> CHAR_BIT) | ((*mem & m2) << CHAR_BIT);
}

এই জাতীয় ফাংশন ইউনিকোড ইউসিএস -২ / ইউটিএফ -16 ফাইলের অন্তর্নিহিতা পরিবর্তনের জন্য দরকারী।

Comments

CHAR_BIT # ডেফাইন কোডটি সম্পূর্ণ করতে অনুপস্থিত।

— তানু শমূয়েল

ঠিক আছে, আমি অন্তর্ভুক্ত অন্তর্ভুক্ত।

— প্যাট্রিক Schlüter

এখানে সি ++ এ পরিবর্তনের জন্য একটি লিঙ্ক দেওয়া হয়েছে, আমি t know if itপরামর্শগুলির মতো তত তাড়াতাড়ি এগিয়ে যাচ্ছি তবে তা অবাক হয়ে যায়: github.com/heatblazer/helpers/blob/master/utils.h

— ইলিয়ান জাপ্রিয়ানোভ ২

CHAR_BITপরিবর্তে নির্ভরশীল 8হিসাবে 0xFF00FF00FF00FF00ULLকৌতূহলযুক্ত CHAR_BIT == 8। নোট করুন যে LLধ্রুবক প্রয়োজন হয় না।

— chux - মনিকা 13

আপনি ঠিক chux। কেবলমাত্র CHAR_BITসেই ম্যাক্রোর এক্সপোজার বাড়ানোর জন্যই লিখেছিলেন । এলএল হিসাবে, এটি অন্য যে কোনও কিছুর চেয়ে বেশি টিকা। এটি একটি অভ্যাস যা আমি বহুদিন আগে বাগি সংকলক (প্রাক মান) দিয়েছিলাম যা সঠিক কাজটি করে না।

— প্যাট্রিক Schlüter

Answer 12

এই কোড স্নিপেট 32 বিট লিট এন্ডিয়ান সংখ্যাটিকে বিগ এন্ডিয়ান সংখ্যায় রূপান্তর করতে পারে।

#include <stdio.h>
main(){    
    unsigned int i = 0xfafbfcfd;
    unsigned int j;    
    j= ((i&0xff000000)>>24)| ((i&0xff0000)>>8) | ((i&0xff00)<<8) | ((i&0xff)<<24);    
    printf("unsigned int j = %x\n ", j);    
}

Comments

ধন্যবাদ @ ইউহাউ আমি এখানে নতুন, পাঠ্যটির বিন্যাস কীভাবে করবেন তা জানেন না।

— দক্ষ বিলোর

((i>>24)&0xff) | ((i>>8)&0xff00) | ((i&0xff00)<<8) | (i<<24);কিছু প্ল্যাটফর্মগুলিতে ব্যবহার করা দ্রুততর হতে পারে (উদাঃ এবং মাস্কের ধ্রুবকগুলি পুনর্ব্যবহার করা)। বেশিরভাগ সংকলকগণ এটি করতে পারে তবে কিছু সাধারণ সংকলক আপনার জন্য এটি অনুকূল করতে সক্ষম হয় না।

Answer 13

আপনি যদি একটি x86 বা x86_64 প্রসেসরের উপর চালনা করেন তবে বড় এন্ডিয়ান স্থানীয় হয়। তাই

16 বিট মান জন্য

unsigned short wBigE = value;
unsigned short wLittleE = ((wBigE & 0xFF) << 8) | (wBigE >> 8);

32 বিট মানগুলির জন্য

unsigned int   iBigE = value;
unsigned int   iLittleE = ((iBigE & 0xFF) << 24)
                        | ((iBigE & 0xFF00) << 8)
                        | ((iBigE >> 8) & 0xFF00)
                        | (iBigE >> 24);

এটি সর্বাধিক দক্ষ সমাধান নয় যতক্ষণ না সংকলকটি স্বীকৃতি দেয় যে এটি বাইট লেভেল ম্যানিপুলেশন এবং বাইট অদলবদ কোড উত্পন্ন করে না। তবে এটি কোনও মেমরি বিন্যাসের কৌশলগুলির উপর নির্ভর করে না এবং খুব সহজেই ম্যাক্রোতে রূপান্তরিত হতে পারে।

Comments

X86 এবং x86_64 আর্কিটেকচারে ছোট এন্ডিয়ান স্কিমটি হ'ল দেশীয়।

— এমকে ওরফে গ্রিসু