روش سادش چیه؟ یه macOS بگیر یا با لینوکس کار کن لازم نیست اینهمه دردسر بکشی.😁 حالا من به عنوان متخصص هیچ تعصبی روی هیچ سیستم‌‌عاملی ندارم اما خب مک یه چیز دیگست. 😉

👀👊🏼 صفحهٔ Claim آزمایشی!

هعی… چقدر بی ارزش داره میشه این اسکانس‌ها! 😕

امسال، سال درخشش توست ✨
نوروزتان پیروز، قدم‌هایتان استوار! 💚🎊🎉🌸

هر دو کتاب مقدماتی و پیشرفته‌ٔ برنامه‌نویسی Qt رو امسال هم با کد تخقیف Nowruz صد در صد رایگان می‌کنم.

کتاب آموزش پیشرفته ++C همراه Qt (پیشرفته) ۱.۳.۸
کتاب آموزش مقدماتی ++C همراه Qt (مقدماتی) ۵.۰

قسمت خرید بخش کوپن رو پر کنید، نباید ازتون پرداخت بخواد، اگر مشکلی هم بود زیر همین پست بهم اطلاع بدین.

این کوپن تا ۱۲ روز دیگه یعنی تولدم اعتبار خواهد داشت.
شاد باشید. :) 👊🏼🤚🏼

می‌فرمایند که کادوی دیگه‌ای بده چون قبلاً کتاب‌هات رو خریدیم. 😁

خب من چیزی رو که الآن دارم و می‌تونم بدم😌، زیر همین پست آدرس کیف‌هاتون روی ERC20 اتریوم (Base) رو بذارید هر موقع توکنی بالا آوردم یه کادوی ناقابل از توکن براتون می‌فرستم.

چرا من باید حس کنم بعضی‌ها روشون نمیشه!؟ بابا بفرستین بیاد بعداً همچین پیشنهاداتی نمیدم‌ها! خدارو چه دیدی شاید پروژه بیاد بترکه بعد یه چیزی هم شمارو شاد کنه. 😄 به هر حال بخشی از قرارداد رو طوری تنظیم کردم که از سهم خودم بتونم بپردازم و مشکلی نیست، پس بفرستین بیاد عیده و بهونه برای خیلی چیز‌ها وجود داره.

کسانی که کیف پول ندارن، یه Metamask ای چیزی بسازن و همون آدرس شبکه اتریومی که بهشون میده رو بفرستند، همون کافیه؛ بعداً می‌گم چه باید کرد.

زیر همون پست قبلی. 👆🏼

ابزار std::invoke_r یک تابع جدید در کتابخانه استاندارد ۲۳ است که در سرآیند <functional> قرار می‌گیرند و برای فراخوانی اشیاء قابل فراخوانی (Callable objects) با پارامترهای دلخواه و بازگرداندن یک مقدار از نوع خاص استفاده می‌شود. این تابع جایگزینی قدرتمند و انعطاف‌پذیر برای std::invoke است که در استاندارد ۱۷ زبان موجود بود که تابع std::invoke معمولاً برای فراخوانی یک تابع با پارامترها استفاده می‌شود.

هر دوی std::invoke و std::invoke_r از توابعی هستند که به ترتیب در استاندارد ۱۷ و ۲۳ برای فراخوانی اشیاء قابل فراخوانی (توابع، توابع عضو، لامبداها و ...) به صورت عمومی معرفی شده‌اند. با این حال، نحوه مدیریت نوع بازگشتی آنها با هم تفاوت دارد که در آن std::invoke یک شیء قابل فراخوانی و آرگومان‌ها را می‌گیرد و آن را مانند یک فراخوانی تابع معمولی اجرا می‌کند و نوع بازگشتی آن همان نوع بازگشتی خود شیء قابل فراخوانی است.

در حالی که تابع std::invoke_r یک ویژگی جدید در استاندارد ۲۳ است که به شما امکان می‌دهد نوع بازگشتی فراخوانی را به طور صریح مشخص کنید و زمانی مفید است که می‌خواهید نوع بازگشتی چیزی متفاوت از نوع بازگشتی اصلی شیء قابل فراخوانی باشد.

مثال:

import std;

int main() {

    auto f = [](int x, int y) { return x + y; };
    std::println("{}", std::invoke(f, 1, 2));
    std::println("{}", std::invoke_r<int>(f, 1, 2));

}

#cpp20 #cpp23 #forward_like #forward #چالش #سی‌روزه #رمضان #روز_هفدهم

بخش تخصصی دوم (به‌روز رسانی Solidity) | تبدیل صریح (Explicit Conversions)

در سالیدیتی اگر کامپایلر تبدیل ناخودآگاه را اجازه ندهد اما شما اطمینان دارید که یک تبدیل کار خواهد کرد، گاهی اوقات تبدیل نوع صریح ممکن است باشد. این ممکن است منجر به رفتارهای غیرمنتظره شود و به شما امکان می دهد تا از برخی از ویژگی‌های امنیتی کامپایلر عبور کنید، بنابراین مطمئن شوید که نتیجه آن چیزی است که می‌خواهید و انتظار دارید!

مثال زیر را در نظر بگیرید که یک عدد منفی را به یک عدد بدون علامت تبدیل می‌کند:

int y = -3;
uint x = uint(y);

در انتهای این قطعه کد، مقدار x برابر 0xfffff..fd (۶۴ حرف هگزادسیمال) خواهد بود، که 3- در نمایش دوتایی با 256 بیت است.
اگر یک عدد صحیح به طور صریح به یک نوع کوچکتر تبدیل شود، بیت‌های سفارشی بالاتر قطع خواهند شد:

uint32 a = 0x12345678;
uint16 b = uint16(a); // // b will be 0x5678 now

اگر یک عدد صحیح به طور صریح به یک نوع بزرگتر تبدیل شود، نتیجهٔ تبدیل برابر عدد صحیح اصلی آن خواهد بود:

uint16 a = 0x1234;
uint32 b = uint32(a); // b will be 0x00001234 now
assert(a == b);

در نوع‌های بایت با اندازه ثابت، رفتارهای متفاوتی را در طول تبدیلات از خود نشان می‌دهند. می‌توان آن‌ها را به عنوان دنباله‌ای از بایت‌های فردی در نظر گرفت و تبدیل به یک نوع کوچکتر منجر به قطع دنباله خواهد شد:

bytes2 a = 0x1234;
bytes1 b = bytes1(a); // b will be 0x12

اگر یک نوع بایت با اندازه ثابت به طور صریح به یک نوع بزرگتر تبدیل شود. دسترسی به بایت در یک فهرست ثابت منجر به همان مقدار قبل و بعد از تبدیل خواهد شد:

bytes2 a = 0x1234;
bytes4 b = bytes4(a); // b will be 0x12340000
assert(a[0] == b[0]);
assert(a[1] == b[1]);

از آنجا که اعداد صحیح و آرایه‌های بایت با اندازه ثابت هنگام قطع یا پر کردن رفتارهای متفاوتی دارند، تبدیل‌های صریح بین اعداد صحیح و آرایه‌های بایت با اندازهٔ ثابت تنها در صورتی مجاز است که هر دو اندازه یکسان باشند. اگر بخواهید بین اعداد صحیح و آرایه‌های بایت با اندازه ثابت با اندازه‌های مختلف تبدیل کنید، باید از تبدیل‌های میانی استفاده کنید که قوانین قطع و پر کردن موردنظر را صریحاً بیان کنند:

bytes2 a = 0x1234;
uint32 b = uint16(a); // b will be 0x00001234
uint32 c = uint32(bytes4(a)); // c will be 0x12340000
uint8 d = uint8(uint16(a)); // d will be 0x34
uint8 e = uint8(bytes1(a)); // e will be 0x12

آرایه‌های بایت و برش‌های داده‌های بایت به طور صریح به نوع بایت‌های ثابت (bytes1/…/bytes32) تبدیل می‌شوند. در صورتی که طول آرایه بیشتر از نوع بایت‌های ثابت مقصد باشد، قطع دنبالهٔ آن‌ها در انتها رخ می‌دهد. اگر طول آرایه کوچکتر از نوع مقصد باشد، در انتها با صفر پر خواهد شد.

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.5;

contract C {
    bytes s = "abcdefgh";
    function f(bytes calldata c, bytes memory m) public view returns (bytes16, bytes3) {
        require(c.length == 16, "");
        bytes16 b = bytes16(m);  // if length of m is greater than 16, truncation will happen
        b = bytes16(s);  // padded on the right, so result is "abcdefgh\0\0\0\0\0\0\0\0"
        bytes3 b1 = bytes3(s); // truncated, b1 equals to "abc"
        b = bytes16(c[:8]);  // also padded with zeros
        return (b, b1);
    }
}

#solidity #web3 #update #ether #اتریوم

ویژگی std::bind_back یک الگوی تابعی جدید در کتابخانهٔ استاندارد ۲۳ است که به عنوان مکملی از std::bind_front به شما امکان می‌دهد ورودی‌ها را به توابع ارجاعی (Callable objects) به صورت "bind" اما با ترتیب برعکس اعمال کنید.

- این تابع، ورودی‌ها را به انتهای یک فراخوانی متصل می‌کند؛ یک شیء قابل فراخوانی (تابع، لامبدا و غیره) و فهرستی از ورودی‌ها را می‌گیرد. این ورودی‌ها اساساً در انتهای فهرست ورودی‌ قابل فراخوانی «از پیش پر شده‌اند» (pre-filled).

- این تابع یک پوشش فراخوانی ارسالی ایجاد می‌کند. تابع std::bind_back یک شیء قابل فراخوان جدید را برمی‌گرداند که ورودی‌های قابل فراخوان اولیه و ورودی‌های محدود را کپسوله می‌کند. هنگامی که این callable جدید را فراخوانی می‌کنید، ورودی‌هایی را که ارائه می‌دهید همراه با ورودی‌های پیش‌پیوندی (pre-bound) به فراخوان اصلی ارسال می‌کند.

به عبارت ساده‌تر، تصور کنید تابعی دارید که چندین ورودی می‌گیرد، اما می‌خواهید برخی از آن ورودی‌ها را از قبل اصلاح کنید. در اینجا، تابع std::bind_back به شما امکان می‌دهد این کار را با ایجاد یک شیء تابع مانند جدید، که از قبل دارای مقادیر مشخصی پر شده است، انجام دهید.

به طور کلی، ورودی‌هایی که به std::bind_back ارائه می‌دهید کپی یا منتقل می‌شوند (با مرجع ارسال نمی‌شوند) مگر اینکه از std::ref یا std::cref استفاده کنید.

import std;

auto main() -> int {
    auto add = [](int a, int b) { return a + b; };
    auto bound_add = std::bind_back(add, 10);
    std::println("{}", bound_add(5));
}

#cpp20 #cpp23 #bind #bind_back #چالش #سی‌روزه #رمضان #روز_هجدهم

بخش تخصصی دوم (به‌روز رسانی Solidity) | دید کلی توابع (Function Visibility)

سالیدیتی دو نوع فراخوانی تابع را می‌شناسد، البته با توجه به سبک برنامه‌نویسی در ++C و Java که خصوصیات OOP را به خوبی به نمایش می‌گذارند، در سالیدیتی نیز ما شاهد ویژگی‌های مشابه در نوع دید اعضای یک کلاس (در اینجا قرارداد) هستیم.

بناراین، نوع دید خارجی (external) که یک فراخوان پیام واقعی EVM ایجاد می‌کند و داخلی (internal) که این کار را انجام نمی‌دهد. علاوه بر این، توابع داخلی را می‌توان برای قراردادهای مشتق شده غیرقابل دسترسی کرد. این امر باعث ایجاد چهار نوع دید (visibility) برای توابع می‌شود.

خارجی (external)
توابع خارجی بخشی از رابط کاربری قرارداد هستند، به این معنی که می‌توان از سایر قراردادها و از طریق تراکنش‌ها آنها را فراخوانی کرد. یک تابع خارجی f را نمی‌توان به صورت داخلی فراخوانی کرد، یعنی ()f کار نمی‌کند، اما ()this.f کار می‌کند.

عمومی (public)
توابع عمومی بخشی از رابط‌کاربری قرارداد هستند و می‌توان آنها را به صورت داخلی یا از طریق فراخوانی پیام فراخوانی کرد.

داخلی (internal)
توابع داخلی فقط از درون قرارداد جاری یا قراردادهای مشتق شده از آن قابل دسترسی هستند. آنها به صورت خارجی قابل دسترسی نیستند. از آنجایی که از طریق ABI قرارداد در معرض دید قرار نمی‌گیرند، می‌توانند ورودی‌هایی از انواع داخلی مانند نگاشت ها (mapping) یا مراجع ذخیره‌سازی (storage references) را دریافت کنند.

خصوصی (private)
توابع خصوصی مانند توابع داخلی هستند، اما در قراردادهای مشتق شده قابل مشاهده نیستند.

مشخص‌کننده‌های دید (Visibility Specifiers) در سالیدیتی
مشخص‌کنندهٔ دید در سالیدیتی برای کنترل دسترسی به عناصر قرارداد (متغیرهای حالت و توابع) استفاده می‌شود. انتخاب مناسب این مشخص‌کننده‌ها برای امنیت، ماژولار بودن و بهینه‌سازی مصرف گاز (gas) در قراردادهای هوشمند بسیار مهم است.

مشخص کننده visibility بعد از نوع برای متغیرهای حالت و بین فهرست ورودی و فهرست ورودی‌های برگشتی برای توابع داده می‌شود.

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.4.16 <0.9.0;

contract C {
    function f(uint a) private pure returns (uint b) { return a + 1; }
    function setData(uint a) internal { data = a; }
    uint public data;
}

در مثال زیر، D می‌تواند ()c.getData را برای بازیابی مقدار داده‌ها در ذخیره‌سازی حالت فراخوانی کند، اما قادر به فراخوانی f نیست. قرارداد E از C مشتق شده است و بنابراین، می‌تواند محاسبه را فراخوانی کند.

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.4.16 <0.9.0;

contract C {
    uint private data;

    function f(uint a) private pure returns(uint b) { return a + 1; }
    function setData(uint a) public { data = a; }
    function getData() public view returns(uint) { return data; }
    function compute(uint a, uint b) internal pure returns (uint) { return a + b; }
}

// This will not compile
contract D {
    function readData() public {
        C c = new C();
        uint local = c.f(7); // error: member `f` is not visible
        c.setData(3);
        local = c.getData();
        local = c.compute(3, 5); // error: member `compute` is not visible
    }
}

contract E is C {
    function g() public {
        C c = new C();
        uint val = compute(3, 5); // access to internal member (from derived to parent contract)
    }
}

#solidity #web3 #update #ether #اتریوم

ویژگی std::byteswap یک تابع جدید در استاندارد ۲۳ است که برای جابجایی ترتیب بایت‌ها در یک متغیر عددی به کار می‌رود. این تابع یک ابزار ساده از سرآیند <bit> است که ترتیب بایت‌ها را در یک متغیر انتگرال جابجا می‌کند.

این تابع فقط یک ورودی می‌گیرد که باید یک متغیر عددی باشد. تابع ترتیب بایت‌های متغیر را جابجا می‌کند و یک کپی از متغیر با ترتیب بایت جدید را برمی‌گرداند. در مثال زیر زمانی که داده‌های سریال ‌شده در یک ترتیب بایت متفاوت از endianness اصلی ذخیره شده باشند با استفاده از std::endian و std::byteswap یک راه حل قابل حمل ارائه می‌دهد.

import std;

auto main() -> int {

    uint32_t native_endian = 0x12345678;
    std::println("0x{:x}", native_endian);

    uint32_t flipped_endian = std::byteswap(native_endian);
    // flipped_endian == 0x78563412
    std::println("0x{:x}", flipped_endian);

    // Combining with std::endian
    uint32_t value = 0x0DF0ADBA;
    if constexpr (std::endian::native != std::endian::big)
        value = std::byteswap(value);
    // value == "0xBAADF00D" (on little-endian machines)
    std::println("0x{:X}", value);

}

ماکروی اختصاصی برای بررسی این ویژگی به صورت زیر است:

#ifdef __cpp_lib_byteswap
//TODO...
#endif

#cpp20 #cpp23 #byteswap #endian #چالش #سی‌روزه #رمضان #روز_نوزدهم

بخش تخصصی دوم (به‌روز رسانی Solidity) | توابع گیرنده/دریافت کننده (Getter Functions)

در سالیدیتی، کامپایلر به‌طور خودکار توابع دریافت‌کننده برای تمام متغیرهای وضعیت عمومی ایجاد می‌کند. برای قراردادی که در زیر آمده است، کامپایلر یک تابع به نام "data" ایجاد می‌کند که هیچ ورودی‌ای را دریافت نمی‌کند و یک عدد صحیح (uint)، مقدار متغیر وضعیتی "data" را برمی‌گرداند. متغیرهای وضعیتی می‌توانند هنگامی که اعلام می‌شوند، مقداردهی اولیه شوند.

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.4.16 <0.9.0;

contract C {
    uint public data = 42;
}

contract Caller {
    C c = new C();
    function f() public view returns (uint) {
        return c.data();
    }
}

توابع گیرنده دارای دسترسی خارجی هستند؛ اگر به نماد به‌صورت داخلی دسترسی داده شود (بدون استفاده از this.)، به یک متغیر وضعیتی ارزیابی می‌شود. اگر به‌صورت خارجی دسترسی داده شود (با استفاده از this.)، به یک تابع ارزیابی می‌شود.

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.4.0 <0.9.0;

contract C {
    uint public data;
    function x() public returns (uint) {
        data = 3; // internal access
        return this.data(); // external access
    }
}

اگر شما یک متغیر با دید عمومی (public) از نوع آرایه دارید، آن‌گاه تنها می‌توانید عناصر تکی آرایه را از طریق تابع دریافت‌کننده تولید شده دریافت کنید. این مکانیزم برای جلوگیری از هزینه گاز (gas) بالا هنگام بازگشت آرایه کامل وجود دارد. می‌توانید از ورودی‌ها استفاده کنید تا مشخص کنید کدام عنصر انفرادی باید بازگردانده شود، به عنوان مثال myArray(0). اگر می‌خواهید آرایه کامل را در یک تماس بازگردانید، آن‌گاه باید یک تابع بنویسید، به عنوان مثال:

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.4.16 <0.9.0;

contract arrayExample {
    // public state variable
    uint[] public myArray;

    // Getter function generated by the compiler
    /*
    function myArray(uint i) public view returns (uint) {
        return myArray[i];
    }
    */

    // function that returns entire array
    function getArray() public view returns (uint[] memory) {
        return myArray;
    }
}

حالا می‌توانید به جای myArray(i) که در هر تماس یک عنصر تکی را بازمی‌گرداند؛ از ()getArray برای بازیابی کل آرایه استفاده کنید.

مثال بعدی کمی پیچیده‌تر می‌باشد:

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.4.0 <0.9.0;

contract Complex {
    struct Data {
        uint a;
        bytes3 b;
        mapping(uint => uint) map;
        uint[3] c;
        uint[] d;
        bytes e;
    }
    mapping(uint => mapping(bool => Data[])) public data;
}

یک تابع به شکل زیر تولید می‌شود. نگاشت‌ها (مپ) و آرایه‌ها (به جز آرایه‌های بایت) در ساختار حذف شده‌اند زیرا راه خوبی برای انتخاب اعضای انفرادی ساختار یا ارائه کلید برای مپ وجود ندارد:

function data(uint arg1, bool arg2, uint arg3)
    public
    returns (uint a, bytes3 b, bytes memory e)
{
    a = data[arg1][arg2][arg3].a;
    b = data[arg1][arg2][arg3].b;
    e = data[arg1][arg2][arg3].e;
}

#solidity #web3 #update #ether #اتریوم

توی وب۳، آدرس کیف پولت فقط یه کُد نیست — امضای دیجیتال هویته، ENS تو هویت توئه.
آدمای بزرگ با ساختن یک مسیر شفاف، اعتماد می‌سازن، نه با مخفی بودن.
پایدار باش، قابل ردیابی باش، قابل اعتماد باش.
چون تو این دنیا، اعتماد یعنی سرمایه. 👊🏼

https://warpcast.com/compez.eth/0x5fe71820

قدرت، زادهٔ درد و دوامِ بی‌رحمه؛ نه زادهٔ آسایش و بی‌نیازی.
اونی که قوی شده، از میان زخم، خیانت، سکوت و تاریکی جوشیده… نه از دل راحتی و لبخندهای مصنوعی.

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

شبتون زیبا... 🌙

GM

https://warpcast.com/compez.eth/0x32022763

خب به احتمال قوی من دیگه هیچ پاداشی از فعالیت‌هام توی فارکستر نخواهم گرفت. 😁

هزاران مانع و بی عدالتی، خب اینم روش! جهنم و درک! 👊🏼😎 هیچ اهمیتی نداره واسم.

می‌دونم اینا کسانی رو که مدام میرن تو اسپیس‌ها پشت سر من حرف میزنن که کامپز زیادی بزرگ شده زیادی رشد کرده رو خوشحال می‌کنه! به عمد دارم می‌ذارم که دهن امثال شمارو بعداً صاف کنم! من که می‌دونم از کجا دارم می‌خورم نکتبای بدبخت حسود! 😐 همینکه هیچ‌وقت آدم حسابتون نکردم حسابی آتیشتون زده! با این چیزا هم یکم شاد باشید چون شادی برای شما بیش از این نیست. 😎😉

این دسته افراد منو واقعاً نشناختن هنوز! احمق بدبخت من فارکستر نباشه خودم یه شاه‌کستر می‌سازم! برای کی داری خودتو جر میدی آخه بیچاره. 😁 من یه سازندم مثل تو بدبخت نیستم که بشینم از اینو اون پاداش گدایی کنم من هدفم پاداش دادنه! زمین تا آسمون با چیزی که تو مغز تو هست فرق می‌کنه.