رفتن به مطلب
برای استفاده از انجمن و عضـویت کلیک کنید.

پست های پیشنهاد شده

liberty    0

گروه دانشجو

باسلام
من یک فایل رو داخل برنامم باز کردم، این فایل میتونه هر چیزی باشه مثل فیلم، آهنگ، متن و ...
میخواستم بدونم چطور میشه این فایل رو به آرایه ای از ۰ و ۱ تبدیل کرد و بعد جای ۰ و ۱ ها رو عوض کرد و فایل رو ذخیره کرد؟
میدونم با عملگر bitwise Not اینکار شدنیه ولی مثالی که تحت وین فرم باشه ویا اینکه بتونه یک آرایه رو بگیره و اینکارو بکنه پیدا نکردم.
ممنون میشم راهنمایی بفرمایید.
باتشکر

به اشتراک گذاری این ارسال


لینک به ارسال
Knight    81

گروه دانشجو

میخواستم بدونم چطور میشه این فایل رو به آرایه ای از ۰ و ۱ تبدیل کرد

سلام، اگر میگفتید دقیقاً برای چه کاری میخواید اینکارو انجام بدید بهتر میشد راهنماییتون کرد ولی فک میکنم قصدتون کد کردن فایل هاست.

اگر قصدتون اینه میتونید بجای اینکه بیت به بیت در حافظه قرار بدید و روش عملیات انجام بدید، اطلاعات فایل رو بصورت آرایه ای از بایت ها بر روی حافظه قرار بدید. این کار بوسیله متد ReadAllBytes در کلاس File انجام میشه.

مثال:

byte[] array = File.ReadAllBytes("C:\\a.jpg");

و بعد جای ۰ و ۱ ها رو عوض کرد

 

قبلاً کلاسی نوشته شده به اسم BinOps و تحت مجوز GPL منتشر شده که کارش انجام عملیات باینری بر روی بایت ها است که شامل شیفت به چپ و شیفت به راست و NOT و... میشه.

کد کامل این کلاس به شرح زیره، پس یه کلاس به اسم BinOps ایجاد کن و کدهای زیر رو داخلش قرار بده (اگر خواستی میتونی فقط از قسمت NOT اون استفاده کنی و سایر عملیات رو برای کاهش حجم کدت پاک کنی):

using System;
using System.Threading.Tasks;

namespace MySpace
    {
    public static class BinOps
        {
        private const int bitsinbyte = 8;
        private static readonly int paralleldegree;
        private static readonly int uintsize;
        private static readonly int bitsinuint;
        static BinOps()
            {
            paralleldegree = Environment.ProcessorCount;
            uintsize = sizeof(uint) / sizeof(byte); // really paranoid, uh ?
            bitsinuint = uintsize * bitsinbyte;
            }

        public static byte[] Bin_And(this byte[] ba, byte[] bt)
            {
            int lenbig = Math.Max(ba.Length, bt.Length);
            int lensmall = Math.Min(ba.Length, bt.Length);
            byte[] result = new byte[lenbig];
            int ipar = 0;
            object o = new object();
            System.Action paction = delegate()
            {
                int actidx;
                lock (o)
                    {
                    actidx = ipar++;
                    }
                unsafe
                    {
                    fixed (byte* ptres = result, ptba = ba, ptbt = bt)
                        {
                        uint* pr = (uint*)ptres;
                        uint* pa = (uint*)ptba;
                        uint* pt = (uint*)ptbt;
                        pr += actidx; pa += actidx; pt += actidx;
                        while (pr < ptres + lensmall)
                            {
                            *pr = (*pt & *pa);
                            pr += paralleldegree; pa += paralleldegree; pt += paralleldegree;
                            }
                        }
                    }
            };
            System.Action[] actions = new Action[paralleldegree];
            for (int i = 0; i < paralleldegree; i++)
                {
                actions[i] = paction;
                }
            Parallel.Invoke(actions);
            return result;
            }
            
        public static byte[] Bin_Or(this byte[] ba, byte[] bt)
            {
            int lenbig = Math.Max(ba.Length, bt.Length);
            int lensmall = Math.Min(ba.Length, bt.Length);
            byte[] result = new byte[lenbig];
            int ipar = 0;
            object o = new object();
            System.Action paction = delegate()
                {
                    int actidx;
                    lock (o)
                        {
                        actidx = ipar++;
                        }
                    unsafe
                        {
                        fixed (byte* ptres = result, ptba = ba, ptbt = bt)
                            {
                            uint* pr = (uint*)ptres;
                            uint* pa = (uint*)ptba;
                            uint* pt = (uint*)ptbt;
                            pr += actidx; pa += actidx; pt += actidx;
                            while (pr < ptres + lensmall)
                                {
                                *pr = (*pt | *pa);
                                pr += paralleldegree; pa += paralleldegree; pt += paralleldegree;
                                }
                            uint* pl = ba.Length > bt.Length ? pa : pt;
                            while (pr < ptres + lenbig)
                                {
                                *pr = *pl;
                                pr += paralleldegree; pl += paralleldegree;
                                }
                            }
                        }
                };
            System.Action[] actions = new Action[paralleldegree];
            for (int i = 0; i < paralleldegree; i++)
                {
                actions[i] = paction;
                }
            Parallel.Invoke(actions);

            return result;
            }
            
        public static byte[] Bin_Xor(this byte[] ba, byte[] bt)
            {
            int lenbig = Math.Max(ba.Length, bt.Length);
            int lensmall = Math.Min(ba.Length, bt.Length);
            byte[] result = new byte[lenbig];
            int ipar = 0;
            object o = new object();
            System.Action paction = delegate()
                {
                    int actidx;
                    lock (o)
                        {
                        actidx = ipar++;
                        }
                    unsafe
                        {
                        fixed (byte* ptres = result, ptba = ba, ptbt = bt)
                            {
                            uint* pr = ((uint*)ptres) + actidx;
                            uint* pa = ((uint*)ptba) + actidx;
                            uint* pt = ((uint*)ptbt) + actidx;
                            while (pr < ptres + lensmall)
                                {
                                *pr = (*pt ^ *pa);
                                pr += paralleldegree; pa += paralleldegree; pt += paralleldegree;
                                }
                            uint* pl = ba.Length > bt.Length ? pa : pt;
                            while (pr < ptres + lenbig)
                                {
                                *pr = *pl;
                                pr += paralleldegree; pl += paralleldegree;
                                }
                            }
                        }
                };
            System.Action[] actions = new Action[paralleldegree];
            for (int i = 0; i < paralleldegree; i++)
                {
                actions[i] = paction;
                }
            Parallel.Invoke(actions);

            return result;
            }
            
        public static byte[] Bin_Not(this byte[] ba)
            {
            int len = ba.Length;
            byte[] result = new byte[len];
            
            int ipar = 0;
            object o = new object();
            System.Action paction = delegate()
            {
                int actidx;
                lock (o)
                    {
                    actidx = ipar++;
                    }
                unsafe
                    {
                    fixed (byte* ptres = result, ptba = ba)
                        {
                        uint* pr = (uint*)ptres;
                        uint* pa = (uint*)ptba;
                        pr += actidx; pa += actidx;
                        while (pr < ptres + len)
                            {
                            *pr = ~(*pa);
                            pr += paralleldegree; pa += paralleldegree;
                            }
                        }
                    }
            };
            System.Action[] actions = new Action[paralleldegree];
            for (int i = 0; i < paralleldegree; i++)
                {
                actions[i] = paction;
                }
            Parallel.Invoke(actions);
            return result;
            }
            
        public static byte[] Bin_ShiftLeft(this byte[] ba, int bits)
            {
            int ipar = 0;
            object o = new object();

            int len = ba.Length;
            if (bits >= len * bitsinbyte) return new byte[len];
            int shiftbits = bits % bitsinuint;
            int shiftuints = bits / bitsinuint;
            byte[] result = new byte[len];

            if (len > 1)
                {
                // first uint is shifted without carry from previous byte (previous byte does not exist)
                unsafe
                    {
                    fixed (byte* fpba = ba, fpres = result)
                        {
                        uint* pres = (uint*)fpres + shiftuints;
                        uint* pba = (uint*)fpba;
                        *pres = *pba << shiftbits;
                        }
                    }
                System.Action paction = delegate()
                    {
                        int actidx;
                        lock (o)
                            {
                            actidx = ipar++;
                            }
                        unsafe
                            {
                            fixed (byte* fpba = ba, fpres = result)
                                {
                                // pointer to results; shift the bytes in the result
                                // (i.e. move left the pointer to the result)
                                uint* pres = (uint*)fpres + shiftuints + actidx + 1;
                                // pointer to original data, second byte
                                uint* pba1 = (uint*)fpba + actidx + 1;
                                if (shiftbits == 0)
                                    {
                                    while (pres < fpres + len)
                                        {
                                        *pres = *pba1;
                                        pres += paralleldegree; pba1 += paralleldegree;
                                        }
                                    }
                                else
                                    {
                                    // pointer to original data, first byte
                                    uint* pba2 = (uint*)fpba + actidx;
                                    while (pres < fpres + len)
                                        {
                                        *pres = *pba2 >> (bitsinuint - shiftbits) | *pba1 << shiftbits;
                                        pres += paralleldegree; pba1 += paralleldegree; pba2 += paralleldegree;
                                        }
                                    }
                                }
                            };

                    };
                System.Action[] actions = new Action[paralleldegree];
                for (int i = 0; i < paralleldegree; i++)
                    {
                    actions[i] = paction;
                    }
                Parallel.Invoke(actions);
                }

            return result;
            }
            
        public static byte[] Bin_ShiftRight(this byte[] ba, int bits)
            {
            int ipar = 0;
            object o = new object();
            int len = ba.Length;
            if (bits >= len * bitsinbyte) return new byte[len];
            int ulen = len / uintsize + 1 - (uintsize - (len % uintsize)) / uintsize;
            int shiftbits = bits % bitsinuint;
            int shiftuints = bits / bitsinuint;
            byte[] result = new byte[len];

            if (len > 1)
                {
                unsafe
                    {
                    fixed (byte* fpba = ba, fpres = result)
                        {
                        uint* pres = (uint*)fpres + ulen - shiftuints - 1;
                        uint* pba = (uint*)fpba + ulen - 1;
                        *pres = *pba >> shiftbits;
                        }
                    }
                System.Action paction = delegate()
                    {
                        int actidx;
                        lock (o)
                            {
                            actidx = ipar++;
                            }
                        unsafe
                            {
                            fixed (byte* fpba = ba, fpres = result)
                                {
                                // pointer to results; shift the bytes in the result
                                // (i.e. move left the pointer to the result)
                                uint* pres = (uint*)fpres + actidx;
                                // pointer to original data, first useful byte
                                uint* pba1 = (uint*)fpba + shiftuints + actidx;
                                if (shiftbits == 0)
                                    {
                                    while (pres < ((uint*)fpres) + ulen - shiftuints - 1)
                                        {
                                        *pres = *pba1;
                                        // increment pointers to next position
                                        pres += paralleldegree; pba1 += paralleldegree;
                                        }
                                    }
                                else
                                    {
                                    // pointer to original data, second useful byte
                                    uint* pba2 = (uint*)fpba + shiftuints + actidx + 1;
                                    while (pres < ((uint*)fpres) + ulen - shiftuints - 1)
                                        {
                                        // Core shift operation
                                        *pres = (*pba1 >> shiftbits | *pba2 << (bitsinuint - shiftbits));
                                        // increment pointers to next position
                                        pres += paralleldegree; pba1 += paralleldegree; pba2 += paralleldegree;
                                        }
                                    }
                                }
                            };
                    };
                System.Action[] actions = new Action[paralleldegree];
                for (int i = 0; i < paralleldegree; i++)
                    {
                    actions[i] = paction;
                    }
                Parallel.Invoke(actions);
                }
            return result;
            }
        }
    }

اینجا دو نکته وجود داره، اول اینکه برای کامپایل این کد لازمه که کامپایلر با سوییچ /unsafe فراخونی بشه. پس از منوی Project -> Properties -> Build گزینه 'Allow unsafe code' رو تیک بزن.

دوم اینکه بخاطر استفاده از Threading.Tasks نیازه که از دات نت فریمورک مورد استفادت نسخه 4.0 به بالا استفاده کنید. اگر میخواید از نسخه پایینتر دات نت استفاده کنید باید خودتون کد رو بدون استفاده از Threading.Tasks بازنویسی کنید که پیشنهاد میکنم اینکارو نکنی چون نویسنده این کلاس شیوه های مختلفی رو امتحان کرده تا به بالاترین پرفورمنس در این کد برسه، ولی اگر اصرار به انجام اینکار داری تغییر این کد با توجه به الگوریتم موجود چندان سخت نخواهد بود، حتی میتونی یه حلقه for بذاری و هر خانه از آرایه رو NOT کنی و در آرایه جدید ذخیره کنی و در نهایت return کنی و در واقع با کمتر از ده خط کد کاری که میخوای رو انجام بدی. علت اینکه کد رو خودم بصورت ساده ننوشتم و این کلاس رو قرار دادم هم همین موضوعه (پرفورمنس برنامت بالا باشه)

و سوم اینکه یادت نره namespace کلاسی که در بالا قرار دادم رو مطابق با namespace پروژت تغییر نام بدی

 

بعد از اینکه کلاس رو ایجاد کردید میتونید با استفاده از کد زیر آرایه خودتون رو NOT کنید:

byte[] result = array.Bin_Not();

حالا در داخل آرایه result مقدار NOT شده آرایه اصلی که با محتوای فایلت پر شده قرار گرفته.

 

و فایل رو ذخیره کرد

اینکار هم به سادگی مرحله اول هست، کافیه بنویسی:

File.WriteAllBytes("C:\\b.jpg", result);

اینجوری محتویات آرایه result (که همون NOT شده آرایه array هست) در داخل فایل b.jpg ذخیره میشه

 

 

اگر حتماً لازمه که فایلتون آرایه ای از بیت ها باشه بفرمایید که راهنمایی کنم، من گفتم بایت چون نمیخواستم پرفورمنس برنامتون پایین بیاد و برای هدفی که تو ذهن منه قطعاً بایت توجیح پذیر و بیت مردود هست.

اگر هم میخواید بصورت معمولی و ساده و بدون استفاده از کلاس از Bitwise Operation استفاده کنید باز هم بفرمایید که راهنماییتون کنم (که اینکارم توصیه نمیکنم)

  • پسندیدم 2

به اشتراک گذاری این ارسال


لینک به ارسال

برای ارسال دیدگاه یک حساب کاربری ایجاد کنید یا وارد حساب خود شوید

برای اینکه بتوانید دیدگاهی ارسال کنید نیاز دارید که کاربر سایت شوید

ایجاد یک حساب کاربری

برای حساب کاربری جدید در سایت ما ثبت نام کنید. عضویت خیلی ساده است !

ثبت نام یک حساب کاربری جدید

ورود به حساب کاربری

دارای حساب کاربری هستید؟ از اینجا وارد شوید

ورود به حساب کاربری

  • مطالب مشابه

    • توسط محمد سینا موثقی نژاد
      با سلام و عرض احترام به تمامی کاربران انجمن لرن نت

      بنده مفهوم و کاربرد کد زیر را متوجه نشده ام اگر کسی فهمیده میتونه توضیح بده
      int[,] grid = new int[5, 10]; var smallerGrid = new int[,] { { 1, 2, 3, 4 }, { 2, 3, 4, 5 }, { 3, 4, 5, 6 }, };
      توضیحات کد : 
       
      As you can see, rectangular array type names have only a single pair of square brackets, no matter how many dimensions they support. The number of commas inside the brackets denotes the
      number of dimensions, so these examples with one comma are two-dimensional. The initializer syntax is very similar to that for multidimensional arrays (see Example 5-19) except I do not start each row with new[], because this is one big array, not an array of arrays. The numbers in Example 5-20 form a shape that is clearly rectangular, and if you attempt to make things jagged with different line lengths, the compiler will report an error. This extends to higher dimensions. If you wanted a three-dimensional “rectangular” array, it would need to be a cuboid. Example 5-21 shows a cuboid array. You could think of the initializer as being a list of two rectangular slices making up the cuboid. And you can go higher, with hypercuboid arrays (although they are still referred to asrectangular, regardless of how many dimensions you use).

      موفق باشید.
    • توسط spboy
      درود...

      دوستان من یه برنامه با Vb.net باید بنویسم که کار زیر رو انجام بده :

      توسط یک تایمر هر 1 ثانیه یه عدد که متغیر هست خونده بشه

      و ریخته بشه توی آرایه(حالا ممکنه برنامه 100 ثانیه نیاز به دریافت داشته باشه و تعداد سقف مشخص است اما تعداد اعداد دریافتی مشخض نیست)

      و بعد اعداد جمع بشه و تقسیم بر تعدادشون بشه.

      مرحله اول که خیلی آسونه مرحله دوم هم من با تعداد مشخصی عدد تونستم انجامش بدم و مرحله سوم هم که آسون.

      مرحله دوم فقط تعداد من مشخص نیست یعنی ممکنه 20 تا عدد باشه ، ممکنه 50 تا باشه ، ممکنه اصلا 5 تا باشه

      این رو چجوری باید توی آرایه مشخص کنم ؟

      اعداد همشون اعشاری و نزدیک به صفر هستن ، و احتمال صفر شدنشونم هست

      من خواستم کدی رو بنویسم که اگر صفر شد بقیه رو دیگه ادامه نده ولی دیدم ممکنه عدد صفر هم بشه

      ممنون میشم راهنمایی کنید
    • توسط علی کرباسی
      برای انجام عملیات بر روی داده ها از عملگرها استفاده می کنیم. عملگرها نمادهایی هستند که عملیاتی مانند جمع،ضرب، کوچکتری و از این قبیل را روی داده ها انجام می دهند که عبارتند از :
      انتساب ( Assignment ) ( = )
      از این عملگر برای نسبت دادن یک مقدار به یک داده استفاده می شود .
      #include <iostream> int main() { int a, b ; // a:?, b:? a = 10 ; // a:10, b:? b = 4 ; // a:10, b:4 a = b ; // a:4, b:4 b = 7 ; // a:4, b:7 cout << "a:" ; cout << a ; cout << "b:" ; cout << b ; return 0 ; } نحوه عملکرد این عملگرد به این شکله که مقدار سمت راست تساوی را در سمت چپ قرار می دهد.
      عملگرهای محاسباتی ( Arithmetic Operators ) ( + , - , * , / , % )
      پنج عملگر محاسباتی موجود در C++ عبارتند از :
      جمع (+) تفریق (-) ضرب (*) تقسیم (/) باقیمانده تقسیم (%) با 4 عملگرد اول آشنا هستید اما آخرین که خوانده می شود ( مـد "با واو تلفظ کنید" ) عملوند سمت چپ را بر عملوند سمت راست تقسیم کرده و باقیمانده آنرا بدست می آورد .
      #include <iostream> int main() { int a = 11; int b = 3; int c = a % b; cout >> "c:" ; cout >> c ; return 0 ; } عملگرهای ترکیبی ( Compund Operators ) ( =+ , =- , =* , =/ )
      در واقع جواب این نوع از عملگرها برابر حاصل عمل عملگر، بر خود عبارت سمت چپ و عبارت سمت راست تساوی است . علت اینگونه نوشتار هم مختصرنویسی است.
      عملگرهای ترکیبی دیگری نیز وجود دارند که در ادامه در موردشان بحث می کنیم مثل : => و =<
      #include <iostream> int main() { int a ,b = 3; // a=?, b=3 a = b; // a=3, b=3 a += 2; // a=a+2=3+2=5 cout >> a; return 0 ; } عملگرهای افزایش کاهش ( Increase , Decrease ) ( ++ , -- )
      این عملگرها یک واحد به عملوند خود اضافه می کنند و عمل اونها به اینکه در سمت چپ یا راست عملوند خود قرار بگیرند متفاوت است .
      #include <iostream> int main() { int a = 2, b = 3; // a=2, b=3 a += b++; // a+=(b+1) ---> a=a+(b+1) ---> a=2+4=6 cout >> "a:"; cout >> a; return 0; } اگر عملگر سمت راست یا چپ عملوند خود باشه در هر دو صورت یک واحد به عملوند اضافه می شود . اما تفاوت این دوحالت در عبارات محاسباتی خود را نشان می دهد . عبارات محاسباتی ترکیبی از متغیرها، ثوابت و عملگرها هستند مثل 4*5-5/10 و 6-x/y
      int A , B = 3; // A=?, B=3 A = ++B; // A=(++B) ---> A=(B+1) , B=B+1 ---> A=4, B=4 در مثال بالا چون افزایش قبل B قرار دارد ابتدا یک واحد به B اضافه شده، پس در همینجا B می شود 4 و در پایان مقدار فوق در A قرار می گیرد .
      int A , B = 3; // A=?, B=3 A = B++; // A=(B++) ---> A=B, B=B+1 ---> A=3, B=4 اما در مثال بالا چون افزایش بعد از B قرار دارد اول مقدار B که 3 هست در A ریخته میشود و بعد یک واحد به B اضافه میشود .
      عملگرهای رابطه ای و تساوی (Relational and equality operators) ( = = , =! , > , < , =< , => )
      از این نوع عملگرها برای مقایسه دو عبارت استفاده میشود که کاربرد اونها بیشتر در عبارات شرطی است که بعدا در موردشون بحث می کنیم . فعلا اینو بدونید که این عملگرها در صورت درست بودن مقایسه، مقدار درستی و در غیر این صورت مقدار نادرستی را برمی گردانند .
      int a = 10 , b = 7; //a=10, b=7 (a == b) ; //a=10 and not equal to b so return false (a >= b) ; //a=10 greater than b so return false (a > b) ; //a=10 greater than b so return true عملگرهای دیگه ای هم وجود دارند که در آینده و با برخورد به اونها در موردشون صحبت می کنم تا مبحث کسل کننده و طولانی نشه 
      موفق باشید 
    • توسط علی کرباسی
      با سلام خدمت تمامی دوستان عزیز و کاربران انجمن لرن نت 
      گاهی وقتها لازمه که یک سری از داده هم نوع را دریافت کرده و روی آنها عملیات خاصی را مثل مقایسه یا مرتب کردن و ... را انجام بدیم ، لذا باید آنها را بگونه ای خاص در کنار یکدیگر قرار بدیم که این مسئله را در برنامه نویسی C++ با آرایه ها حل می کنیم ...
      به دلیل طولانی بودن مطلب و برای راحتی کار  تصمیم گرفتم این آموزش رو به صورت PDF برای شما عزیزان قرار بدم و امیدوارم مفید باشه 
        برای دانلود کلیک کنید  
  • کاربران آنلاین در این صفحه   0 کاربر

    هیچ کاربر عضوی،در حال مشاهده این صفحه نیست.

×