在下一个代码中:

#include <stdio.h>

int main(void) {   
  int c;   
  while ((c=getchar())!= EOF)      
    putchar(c); 
  return 0;
}

我必须按Enter下来打印我输入的所有字母getchar,但我不想这样做,我想要做的就是按下这封信,然后立即看到我重复介绍的信,而不是按下Enter.例如,如果我按下'a'字母,我想在旁边看到另一个'a',依此类推:

aabbccddeeff.....

但当我按'a'时没有任何反应,我可以写其他字母,只有当我按下时才会出现副本Enter:

abcdef
abcdef

我怎样才能做到这一点？

我正在使用cc -o example example.cUbuntu下的命令进行编译.

我有这个代码：

typedef struct {\n    int test;\n} SensorData_t;\nvolatile SensorData_t sensorData[10];\n\nSensorData_t getNextSensorData(int i)\n{\n    SensorData_t data = sensorData[i];\n    return data;\n}\n\n\nint main(int argc, char** argv) {\n\n}\n

它可以使用 gcc 版本 8.3 进行编译，但不能使用 g++ 进行编译。错误信息：

main.c: In function \xe2\x80\x98SensorData_t getNextSensorData(int)\xe2\x80\x99:\nmain.c:8:34: error: no matching function for call to \xe2\x80\x98SensorData_t(volatile SensorData_t&)\xe2\x80\x99\n  SensorData_t data = sensorData[i];\n                                  ^\nmain.c:3:3: note: candidate: \xe2\x80\x98constexpr SensorData_t::SensorData_t(const SensorData_t&)\xe2\x80\x99 <near match>\n } SensorData_t;\n   ^~~~~~~~~~~~\nmain.c:3:3: note:   conversion of argument 1 would be ill-formed:\nmain.c:8:34: error: binding reference of type \xe2\x80\x98const SensorData_t&\xe2\x80\x99 to \xe2\x80\x98volatile SensorData_t\xe2\x80\x99 discards …

问题:

我见过这样的问题:

1. count the number of 0s between 0 and N?
2. count the number of 1s between 0 and N?
3. count the number of 2s between 0 and N?
4. ......

这些类型的问题与要求查找Ks (i.e. K=0,1,2,...,9)数字范围中显示的总数非常相似[0, N].

例:

• 输入: K=2, N=35
• 输出: 14
• 细节:2s之间的列表[0,35]:2, 12, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 32,注意22将被计为两次(22包含两个2s)

我们有什么:

每种方案都有解决方案(如果您搜索它,则可用).通常,O(log N)需要时间来通过递归地考虑最高位来解决这些问题,等等.计算0到N之间2的数量的一个例子可以通过以下过程解决(从这里借用):

// Take n = …

我试图了解Java中对象创建背后的实际过程-并且我想使用其他编程语言。

假定Java中的对象初始化与对C中的结构使用malloc相同是错误的吗？

例：

Foo f = new Foo(10);

typedef struct foo Foo;
Foo *f = malloc(sizeof(Foo));

这就是为什么说对象位于堆而不是堆栈上的原因吗？因为它们本质上只是数据指针？

关于工会我还有一些不明白的问题.我已经阅读了很多他们的用途,并且在大多数情况下可以看到它们如何有用并理解它们.我已经看到他们可以提供原始的"C风格"多态性.我在几个网站上看到的这个例子是SDL的事件联盟:

typedef union {
 Uint8 type;
 SDL_ActiveEvent active;
 SDL_KeyboardEvent key;
 SDL_MouseMotionEvent motion;
 SDL_MouseButtonEvent button;
 SDL_JoyAxisEvent jaxis;
 SDL_JoyBallEvent jball;
 SDL_JoyHatEvent jhat;
 SDL_JoyButtonEvent jbutton;
     SDL_ResizeEvent resize;
 SDL_ExposeEvent expose;
 SDL_QuitEvent quit;
 SDL_UserEvent user;
     SDL_SysWMEvent syswm;
} SDL_Event;

我无法理解的是,如何在那里与活动类型共存的"类型"成员？这些是不是每个只允许一次存在一个,因为它们占据相同的记忆区域？工会不会随时存在,不论是一种类型还是其中一种事件？

我知道每个事件实际上都是一个带有类型成员的结构,例如:

// SDL_MouseButtonEvent

typedef struct{
     Uint8 type;
     Uint8 button;
     Uint8 state;
     Uint16 x, y;
} SDL_MouseButtonEvent;

这怎么有意义？这是否以某种方式允许联合的类型成员表示联合当前的任何结构的类型？当一个联盟的每个成员除了一个结构并且每个结构包含那个成员时,会发生这种奇怪的效果吗？

你可以在不知道对象是哪个结构的情况下访问struct成员吗？

谢谢!

这是一个边缘话题。因为我想了解编程、CPU 缓存、读取 CPU 缓存行等，所以我把它贴在这里。

我在 C/C++ 中实现了 AES 算法。由于在没有硬件支持的情况下执行 GF(2 ⁸ ) 乘法在计算上是昂贵的，我已经优化为使用 AES S-box 的查找表。但不幸的是，基于查找表的实现容易受到缓存定时攻击。因此，由于对 CPU 缓存非常天真，我开始学习它的工作原理，以及如何在不增加任何计算成本的情况下规避这种攻击。

我意识到实际上有 AES NI 指令和 Bit Slice AES 实现，但它们远远超出了我目前的理解。

我从 crypto.SE 了解到，最简单的方法是在查找之前读取所有缓存行或读取整个表。（这也影响了我的表现）但是我不知道如何在软件中实现它，或者它背后的复杂概念。

在OpenSSLaes-x86core.c的C 实现参考指南中—— 作者实现了一个功能：

static void prefetch256(const void *table)
{
    volatile unsigned long *t=(void *)table,ret;
    unsigned long sum;
    int i;

    /* 32 is common least cache-line size */
    for (sum=0,i=0;i<256/sizeof(t[0]);i+=32/sizeof(t[0]))   sum ^= t[i];

    ret = sum;
}

• 在for循环i中增加8 …

所以我有这个问题,我必须使用两个不同的范围规则来计算输出.我知道用词汇范围输出a=3和b=1,但我使用动态范围界定有很难弄清楚输出.
_{注意:下面的代码示例使用C语法,但我们只是将其视为伪代码.}

int a,b;

int p() {
    int a, p;
    a = 0; b = 1; p = 2;
    return p;
}

void print() {
    printf("%d\n%d\n",a,b);
}

void q () {
    int b;
    a = 3; b = 4;
    print();
}

main() {
    a = p();
    q();
}

这是我想出来的.使用动态范围,非本地引用a和b可以更改.所以我有a=2(从p()返回,然后b=4(在q()内).那么输出是2 4？

我正在尝试编写一个程序来显示某些字符常量的数值(if语句中的那些).代码有效,除了一个问题.输出应该在列中很好地对齐,但如下所示,它不是.使列正确排列的最佳方法是什么？

这是我的代码:

#include <stdio.h>
#include <ctype.h>

int main() {

    unsigned char c;

    printf("%3s %9s %12s %12s\n", "Char", "Constant", "Description", "Value");

    for(c=0; c<= 127; ++c){

        if (c == '\n') {
            printf("%3d %7s \t%s \t\t%s%03x\n", c,"\\n","newline","0x", c);

        }else if (c == '\t'){
            printf("%3d %7s \t%s \t\t%s%03x\n", c,"\\t","horizontal tab","0x", c);

        }else if (c == '\v'){
            printf("%3d %7s \t%s \t\t%s%03x\n", c,"\\v","vertical tab","0x", c);

        }else if (c == '\b'){
            printf("%3d %7s \t%s \t\t%s%03x\n", c,"\\b","backspace","0x", c);

        }else if (c == '\r'){
            printf("%3d %7s \t%s …

我正在从以下论文中了解 NEAT：http : //nn.cs.utexas.edu/downloads/papers/stanley.ec02.pdf

我无法理解调整后的适应度如何惩罚大型物种并阻止它们支配种群，我将通过一个例子来证明我目前的理解，希望有人能纠正我的理解。

假设我们有两个物种，A 和 B，物种 A 在上一代做得很好，并给了更多孩子，这一代他们有 4 个孩子，他们的适应度是 [8,10,10,12] 而 B 有 2 个和他们的适应度是 [9,9] 所以现在他们调整后的适应度将是 A[2, 2.5, 2.5, 3] 和 B[4.5, 4.5]。

现在关于分配孩子，该论文指出：“每个物种被分配一个潜在不同数量的后代f'_i，与其成员生物的调整适应度总和成比例”

所以调整适应度的总和是 A 的 10 和 B 的 9 因此 A 得到更多的孩子并不断增长，那么这个过程如何惩罚大型物种并防止它们支配种群？

有一个有向图(可能包含循环),每个节点都有一个值,我们怎么能得到每个节点的可达值之和.例如,在下图中:

节点1的可达和为:2 + 3 + 4 + 5 + 6 + 7 = 27

节点2的可达和为:4 + 5 + 6 + 7 = 22

.....

我的解决方案:为了获得所有节点的总和,我认为时间复杂度为O(n + m),n是节点数,m代表边数.应该使用DFS,对于每个节点,我们应该递归地使用一个方法来找到它的子节点,并在完成它的计算时保存子节点的总和,以便将来我们不需要再次计算它.需要为每个节点创建一个集合,以避免由循环引起的无限计算.

它有用吗？我认为它不够优雅,特别是必须创建许多套装.有没有更好的解决方案？谢谢.