jcmvbkbc

Почему результат вывода именно такой?

After a successful return from one of these system calls, the old
and new file descriptors may be used interchangeably. They refer
to the same open file description (see open(2)) and thus share file
offset and file status flags; for example, if the file offset is modified
by using lseek(2) on one of the descriptors, the offset is also
changed for the other.

char str1[5];
  char str2[3];

  fgets(str1,5,stdin);
  fgets(str2,3,stdin);

Я ожидаю, что при запуске введу слово из 5 букв, потом слово из 3

fgets() reads in at most one less than size characters from stream
and stores them into the buffer pointed to by s.
Reading stops after an EOF or a newline.
If a newline is read, it is stored into the buffer.

void readm(int N, int* X, FILE * dat)
... 
  int *X = nullptr;
  readm(N, X, dat);
...
  writem(N, X, res);

Может стоит вынести флаг в параметры потока

while(!quit) {
        if(difftime(time(NULL), last_cycle) > 30) {
            last_cycle = time(NULL);
            // Тут мои грязные дела
        }
    }

#include <sys/time.h>
#include <pthread.h>
#include <stdbool.h>
#include <string.h>
#include <stdio.h>

struct thread1 {
    pthread_mutex_t lock;
    pthread_cond_t cond;
    bool quit;
};

static void* thread_process(void *p) {
    struct thread1 *arg = p;

    for (;;) {
        bool quit;

        pthread_mutex_lock(&arg->lock);
        if (!arg->quit) {
            struct timeval now;
            struct timespec ts;

            gettimeofday(&now, NULL);
            ts.tv_sec = now.tv_sec + 30;
            ts.tv_nsec = now.tv_usec * 1000;
            pthread_cond_timedwait(&arg->cond, &arg->lock, &ts);
        }
        quit = arg->quit;
        pthread_mutex_unlock(&arg->lock);
        if (quit)
            return NULL;

        // Тут мои грязные дела
    }
    return NULL;
}

int main() {
    pthread_t th;
    struct thread1 arg = {
        .lock = PTHREAD_MUTEX_INITIALIZER,
        .cond = PTHREAD_COND_INITIALIZER,
        .quit = false,
    };
    pthread_create(&th, NULL, thread_process, &arg);

    char cmd[16];
    while(true) {
        scanf("%s", cmd);
        if(!strcmp(cmd, "quit")) {
            pthread_mutex_lock(&arg.lock);
            arg.quit = true;
            pthread_cond_broadcast(&arg.cond);
            pthread_mutex_unlock(&arg.lock);
            break;
        }
        // остальные команды
    }

    pthread_join(th, NULL);
    return 0;
}

char **array;
array = malloc(arr_len);

for(unsigned long step = 0; step <= arr_len; step++)
{
    array[step] =

int main(void)
{
    int (*pmain)(void) = main;
}

например int* func;

Символы повторяются из-за static?

char *_itoa(int i) {
  static int slot;
  static char buf[10][2];
  slot = (slot + 1) % 10;
  buf[slot][0] = i + '0';
  buf[slot][1] = '\0';
  return buf[slot];
}

int main() {

  printf("%s + %s = %s", _itoa(2), _itoa(2), itoa(4));
  _getch();
}

при компиляции флаг из реестра не удаляется. В чем может быть проблема?

Байты из зеленой области, как я понял, это информация линкера golink. Так ли это?

int **matrix = (int**)malloc(matrix_size * sizeof(int));

int **matrix = (int**)malloc(matrix_size * sizeof(int *));

for (int i = 0; i < matrix_size; ++i)
    {
        for (int j = 0; j < matrix_size; ++j)
        {
            if(i > j)
            {
                arr[i] = matrix[i][j];
            }
        }
    }

counter = 0;
    for (int i = 0; i < matrix_size; ++i)
    {
        for (int j = 0; j < matrix_size; ++j)
        {
            if(i > j)
            {
                arr[counter++] = matrix[i][j];
            }
        }
    }

ума не приложу, почему размер void _stdcall foo(short a, short b); параметров равен 8

Как выяснилось, стек растет не только на 4 байта, а на 2.

The stack will always be maintained 16-byte aligned, except within
the prolog (for example, after the return address is pushed), and except where
indicated in Function Types for a certain class of frame functions