小技巧收集

an

带符号整形四舍五入

tScore =static_cast<int>(tScore/10.0 +((tScore>>(sizeof(tScore)*8 - 1))) + 0.5) *10;

类初始化

1.没有虚函数
memset(this ,0,sizeof(ClassName));
2.有虚函数(不知道对不对)
int a =(int)((this));

memset((void *)(a + 4) ,0,sizeof(ClassName));

字符大小写互换

str[i] = str[i] ^ 0x20;

#include <iso646.h>

可以使用宏  or and not 等等

#ifdef  _WIN64
#define offsetof(s,m)   (size_t)( (ptrdiff_t)&reinterpret_cast<const volatile char&>((((s *)0)->m)) )
#else
#define offsetof(s,m)   (size_t)&reinterpret_cast<const volatile char&>((((s *)0)->m))
#endif

vs  输入提示   Ctrl+Alt+t

//是否是素数

质数还有一个特点，就是它总是等于 6x-1 或者 6x+1，其中 x 是大于等于1的自然数。

    如何论证这个结论呢，其实不难。首先 6x 肯定不是质数，因为它能被 6 整除；其次 6x+2 肯定也不是质数，因为它还能被2整除；依次类推，6x+3 肯定能被 3 整除；6x+4 肯定能被 2 整除。那么，就只有 6x+1 和 6x+5 (即等同于6x-1) 可能是质数了。所以循环的步长可以设为 6，然后每次只判断 6 两侧的数即可

bool IsPrime(int n)
{
    if (n % 6 != 1 && n % 6 != 5)
        return false;
    for (int i = 5; i <= sqrt(n); i += 6)
    {
        if (n % i == 0 || n % (i + 2) == 0)
            return false;
    }
    return true;
}

//公约数
long long gcd(long long a, long long b)
{
    if (b == 0) return a;
    return gcd(b, a%b);
}
//公倍数
long long lcm(long long a, long long b)
{
    return a / gcd(a, b)*b;
}

c++设置宽度和精度

//设置宽度
    cout << 123 << endl;
    cout.width(10);
    cout << 123 << endl;
    
    //设置宽度 + 填充数据
    cout.width(10);
    cout.fill('0');
    cout << 123 << endl;

    cout << setw(4) << 123.0 << endl;

    //cout << fixed;

    //设置精度 fixed 固定位数
    double a = 1.23456789;
    cout << fixed<<setprecision(8) << (double)123.0 << endl;
    cout << setprecision(8) << a << endl;

设置字符集

wchar_t str[20] = L"你好吗";
	wcout.imbue(locale("CHS"));
	wcout << str << endl;

n&(n-1)作用：将n的二进制表示中的最低位为1的改为0

n&-n 树状数组

std::atomic_flag a = ATOMIC_FLAG_INIT;

std::atomic<bool> b(true);
    //加载数据
    bool x = b.load(std::memory_order_acquire);
    //存储
    b.store(true);
    //替换
    x = b.exchange(false, std::memory_order_acq_rel);

//windows debug内存泄露检测//内存泄露检测

inline void EnableMemLeakCheck()
{
    _CrtSetDbgFlag(_CrtSetDbgFlag(_CRTDBG_REPORT_FLAG) | _CRTDBG_LEAK_CHECK_DF);
}

#ifdef _DEBUG
#define new new(_NORMAL_BLOCK, __FILE__, __LINE__)
#endif

消除警告

UNREFERENCED_PARAMETER(hPrevInstance);
UNREFERENCED_PARAMETER(lpCmdLine);

最大最小元素对

minmax_element(a.begin(),a.end());

string 与CString互换

string name = (CStringA)m_user;

 CString m_user;
 m_user = it->first.c_str();

%nd 输出的整型宽度至少为n位，右对齐，%5d即宽度至少为5位，位数大于5则输出实际位数
%0nd 用得比较多，表示输出的整型宽度至少为n位，不足n位用0填充

全排列

首先从后向前查找第一个顺序对 (i,i+1)(i,i+1)，满足 a[i] < a[i+1]a[i]<a[i+1]。这样「较小数」即为 a[i]a[i]。此时 [i+1,n)[i+1,n) 必然是下降序列。

如果找到了顺序对，那么在区间 [i+1,n)[i+1,n) 中从后向前查找第一个元素 jj 满足 a[i] < a[j]a[i]<a[j]。这样「较大数」即为 a[j]a[j]。

交换 a[i]a[i] 与 a[j]a[j]，此时可以证明区间 [i+1,n)[i+1,n) 必为降序。我们可以直接使用双指针反转区间 [i+1,n)[i+1,n) 使其变为升序，而无需对该区间进行排序。

    void nextPermutation(vector<int>& nums) {
        static auto speedup = [](){ios::sync_with_stdio(false);cin.tie(nullptr);return nullptr;}();
        if(nums.size() < 2) return ;
        auto beBig = [](int a,int b){return a < b;};
        int index = -1;
        for(int i = nums.size() - 2;i>=0;--i){
            if(beBig(nums[i],nums[i+1])){
                index = i;
                break;
            }
        }
        if(index == -1) {reverse(nums.begin(),nums.end());return;};
        int last = index+1;
        for(int i = last + 1;i<nums.size();++i){
            if(!beBig(nums[index] , nums[i]))break;
            last = i;
        }
        swap(nums[index],nums[last]);
        reverse(nums.begin()+index+1,nums.end());
    }

二进制枚举子集

for ( j = i; j; j = i & (j - 1))

int read() {
    int s = 0,f = 1;
    char ch = getchar();
    while(ch < '0' or ch > '9') {
        if(ch == '-') f = -1;
        ch = getchar();
    }
    while(ch >= '0' and ch <= '9') {
        s = s * 10 + ch - '0';
        ch = getchar();
    }
    return s * f;
}

生成递增序列

iota(a.begin(),a.end(),0);

vector<int> pal;

auto init = [] {
    // 严格按顺序从小到大生成所有回文数（不用字符串转换）
    for (int base = 1; base <= 10000; base *= 10) {
        // 生成奇数长度回文数
        for (int i = base; i < base * 10; i++) {
            int x = i;
            for (int t = i / 10; t; t /= 10) {
                x = x * 10 + t % 10;
            }
            pal.push_back(x);
        }
        // 生成偶数长度回文数
        if (base <= 1000) {
            for (int i = base; i < base * 10; i++) {
                int x = i;
                for (int t = i; t; t /= 10) {
                    x = x * 10 + t % 10;
                }
                pal.push_back(x);
            }
        }
    }
    pal.push_back(1'000'000'001); // 哨兵，防止下面代码中的 i 下标越界
    return 0;
}();