小编use*_*687的帖子

typedef struct foo
{
    void (*const t)(struct foo *f);
} foo;

void t(struct foo *f)
{
    
}

void (*const myt)(struct foo *f) = t;

foo f = {.t = t};

int main(void)
{
    f.t(&f);
    myt(&f);

    return 0;
}

当使用 x86-64 gcc 13.2 和 clang 16.0.0 编译上述代码时，会生成类似的汇编代码。下面显示的是 gcc 输出。

t:
        ret
main:
        sub     rsp, 8
        mov     edi, OFFSET FLAT:f
        call    [QWORD PTR f[rip]]
        xor     eax, eax
        add     rsp, 8
        ret
f:
        .quad   t
myt:
        .quad   t

为什么两个编译器t在通过函数调用时发出对函数的调用struct foo …

我在这一行得到零错误除法:

if (tim2_st_ovf < T2_PREK_250)

这些值的定义如下:

volatile uint8_t tim2_st_ovf = 0;

#define T2_PREK_250    ((250 * (F_CPU / 1000)) / ((UINT8_MAX + 1) * 1024))
#define F_CPU    16000000UL

和UINT8_MAX等于255.

我为什么要这个？我在计算器上计算了好几次,得到了~15.此外,如果我将1024更改为1023它不会显示任何错误.

我想要实现这样的事情:

#define MACRO(x) {PORTB=0,PORTC=0,PORTD=0}

MACRO(0); //This would get replaced by PORTB=0;
MACRO(1); //PORTC=0;
MACRO(2); //PORTD=0;

我想创建一个"宏数组".我会传入一个索引,它会返回正确的代码.

这可能吗？

编辑:

如果有帮助,PORTB,PORTC和PORTD都是#defines.

任何人都可以帮我创建一个算法,IComparer,或一些排序数组或PointF元素列表的方法.可以说我PointF在我的数组中有以下元素:

• [0] { X = 50.0 Y = 0.0}
• [1] { X = 100.0 Y = 100.0}
• [2] { X = 0.0 Y = 100.0}
• [3] { X = 100.0 Y = 0.0}
• [4] { X = 0.0 Y = 0.0}
• [5] { X = 100.0 Y = 50.0}
• [6] { X = 50.0 Y = 100.0}

我想要实现的是:

• 首先是Y和X最低的元素
• 仍然是Y值最低的元素,但X会变大
• 然后作为在这个最低Y得到的最高可能X得到它,所有元素都有这个X,但是Y …

如果静态分配了一个函数指针数组，我是否仍然需要free()它？可以说我有以下代码：

typedef void (*test_ptr)(void);

int main(void) 
{
    test_ptr test[3];
    test[0] = a;
    test[1] = b;
    test[2] = c;
}

因此，当我完成该操作后，是否需要释放所有指针，也许像这样：

for(int i = 0; i < 3; i++) {
    free(test[i]);
}

还是像其他数组一样在函数结束时自动取消分配？

我在网上找到了这段代码:

CHAR getch() {
    DWORD mode, cc;
    HANDLE h = GetStdHandle( STD_INPUT_HANDLE );

    if (h == NULL) {
        return 0; // console not found
    }

    GetConsoleMode( h, &mode );
    SetConsoleMode( h, mode & ~(ENABLE_LINE_INPUT | ENABLE_ECHO_INPUT) );
    TCHAR c = 0;
    ReadConsole( h, &c, 1, &cc, NULL );
    SetConsoleMode( h, mode );
    return c;
}

使用它像:

while(1) {
    TCHAR key = getch();
}

我能够获得数字,字母甚至返回按键.但我无法逃脱或其他功能键如控制,alt.是否可以修改它以检测这些键？

假设我有以下代码：

void test(void) 
{        
    #define INIT_DONE
    //General initialization stuff
}

void test2(void)
{
    #ifndef INIT_DONE
    #error "Call function test() first!"
    #endif
    // Specific initialization stuff
}

然后main()我按如下方式调用这些函数：

int main(void)
{
    test();
    test2();
}

即使我test()先打电话，#define INIT_DONE我仍然得到：

“首先调用函数 test()！”

编译器上的错误。

那么，我怎样才能实现该函数test()必须在任何其他函数之前首先被调用。我可以用一些全局布尔变量或其他东西来做到这一点，但我希望有一种预处理器方法可以做到这一点。有没有？

我有一个像这样的常数数组:

const int foo[NUM] = {
    9000,
    4400,
    620,
    480,
    1620
};

如何创建另一个const数组,它将对来自foo的变量进行一些数学运算？我试过这个:

const int bar[NUM] = {
    foo[0] / (DEFINE1* DEFINE2),
    foo[1] / (DEFINE1* DEFINE2),
    foo[2] / (DEFINE1* DEFINE2),
    foo[3] / (DEFINE1* DEFINE2),
    foo[4] / (DEFINE1* DEFINE2)
};

但是这不起作用,它会返回错误:

所有元素的错误2('bar [0]'接近初始化)

对于所有元素,错误1初始化元素不是常量

我有一个这样的课:

class Test
{
private:
    Test() {}
    static bool is_done;
    static void ThreadFunction();
public:
    static void DoSomething();
}


bool Test::is_done = true;

void Test::DoSomething()
{
    std::thread t_thread(Test::ThreadFunction);

    while (true) {
        if (is_done) {
            //do something else
            is_done = false;
        }

        if (/*something happened*/) { break; }
    }

    // Finish thread.
    t_thread.join();
}

void Test::ThreadFunction()
{
    while (true) {
        if (/*something happened*/) {
            is_done = true;
        }
    }
}

在主要我然后只需调用Test :: DoSomething(); 在这种情况下,变量'is_done'是否安全？如果不是我怎么能安全阅读呢？