Então, atualmente estou trabalhando na minha própria implementação do comando top usando o ncurses e os arquivos de sistema do Ubuntu e tenho me perguntado quais são exatamente as tarefas que ele mostra.

Eu entendi que esses são os processos em execução no dispositivo, mas estou procurando a pasta Ubuntu onde posso ver o número total de tarefas ou as diferentes tarefas em execução.

Sou novo em programação C. Estou tentando escrever uma estrutura C em um arquivo e lê-la de volta. Estou usando valgrind para verificar vazamentos de memória e possíveis erros. Recebo um conjunto de erros valgrind quando executo o programa e nenhum vazamento de memória. O programa também grava os dados com precisão no arquivo e lê os dados de volta do arquivo. Criei um programa de teste separado ( testRead) para testar a leitura do arquivo depois que o programa de teste para gravar o arquivo ( testUsers) é executado, e os dados são lidos de volta corretamente. Também posso verificar se os dados estão corretos no disco usando hexdump. O que os erros valgrind significam - quais são os bytes não iniciados referenciados na mensagem de erro?

O erro retornado pela execução:valgrind -s --track-origins=yes --leak-check=full --show-leak-kinds=all ./testUsers

==1155442== HEAP SUMMARY:
==1155442==     in use at exit: 0 bytes in 0 blocks
==1155442==   total heap usage: 11 allocs, 11 frees, 10,448 bytes allocated
==1155442== 
==1155442== All heap blocks were freed -- no leaks are possible
==1155442== 
==1155442== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0)
==1155442== 
==1155442== 1 errors in context 1 of 1:
==1155442== Syscall param write(buf) points to uninitialised byte(s)
==1155442==    at 0x4989887: write (write.c:26)
==1155442==    by 0x48FFEEC: _IO_file_write@@GLIBC_2.2.5 (fileops.c:1180)
==1155442==    by 0x49019E0: new_do_write (fileops.c:448)
==1155442==    by 0x49019E0: _IO_new_do_write (fileops.c:425)
==1155442==    by 0x49019E0: _IO_do_write@@GLIBC_2.2.5 (fileops.c:422)
==1155442==    by 0x4900FD7: _IO_file_close_it@@GLIBC_2.2.5 (fileops.c:135)
==1155442==    by 0x48F3D8E: fclose@@GLIBC_2.2.5 (iofclose.c:53)
==1155442==    by 0x10991E: saveToFile (in /home/mark/ESP32-Projects/esp32-launcher/sandbox/users-binary_save/testUsers)
==1155442==    by 0x109D0E: main (in /home/mark/ESP32-Projects/esp32-launcher/sandbox/users-binary_save/testUsers)
==1155442==  Address 0x4aa17f6 is 6 bytes inside a block of size 4,096 alloc'd
==1155442==    at 0x4848899: malloc (in /usr/libexec/valgrind/vgpreload_memcheck-amd64-linux.so)
==1155442==    by 0x48F3BA3: _IO_file_doallocate (filedoalloc.c:101)
==1155442==    by 0x4902CDF: _IO_doallocbuf (genops.c:347)
==1155442==    by 0x4901F5F: _IO_file_overflow@@GLIBC_2.2.5 (fileops.c:744)
==1155442==    by 0x49006D4: _IO_new_file_xsputn (fileops.c:1243)
==1155442==    by 0x49006D4: _IO_file_xsputn@@GLIBC_2.2.5 (fileops.c:1196)
==1155442==    by 0x48F4FD6: fwrite (iofwrite.c:39)
==1155442==    by 0x1098A5: saveToFile (in /home/mark/ESP32-Projects/esp32-launcher/sandbox/users-binary_save/testUsers)
==1155442==    by 0x109D0E: main (in /home/mark/ESP32-Projects/esp32-launcher/sandbox/users-binary_save/testUsers)
==1155442==  Uninitialised value was created by a heap allocation
==1155442==    at 0x4848899: malloc (in /usr/libexec/valgrind/vgpreload_memcheck-amd64-linux.so)
==1155442==    by 0x1095F6: findUser (in /home/mark/ESP32-Projects/esp32-launcher/sandbox/users-binary_save/testUsers)
==1155442==    by 0x1094F4: createUser (in /home/mark/ESP32-Projects/esp32-launcher/sandbox/users-binary_save/testUsers)
==1155442==    by 0x1093DE: initDB (in /home/mark/ESP32-Projects/esp32-launcher/sandbox/users-binary_save/testUsers)
==1155442==    by 0x109AFF: main (in /home/mark/ESP32-Projects/esp32-launcher/sandbox/users-binary_save/testUsers)

usuários.h

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

#define MAX_USERS 3
#define MAX_USER_NAME_SIZE 20

#define PERMISSION_LAUNCH 4
#define PERMISSION_EDIT_USER 2
#define PERMISSION_EDIT_LAUNCHER 1

typedef struct {
  char user_name[20];
  char password[20];
  int permissions;
  int index;
} User;

typedef struct {
    int code;
    char *message;
    char* payload;
} Error;

extern char* user_names[MAX_USERS][MAX_USER_NAME_SIZE];

Error create_error(int code, char *message);

Error createUser(char* user_name, char* password, int permissions);

User* findUser(char * user_name);

void printUsers();

Error initDB();

void deleteUsers();

Error saveToFile();

Error readFromFile();

usuários.c

#include <stdio.h>
#include <stdbool.h>
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "users.h"

/* An array of pointers to the User structs created */
static User* users_storage[MAX_USERS];

/* The number of users in the users_storage array */
int user_counter = 0;

/* File name for saving the users_storage to disk */
const char* USER_FILE_NAME = "users.dat"; 

/*
A struct to return error messages to the UI as needed for errors that come up.
There are no different error codes, just 0 for success and -1 for an error. The UI
Would check the error code and then display the error message.
*/
Error create_error(int code, char *message) {
    Error err;
    err.code = code;
    err.message = message;
    err.payload = "Nothing to see here.";
    return err;
}

/*
Null out the users_storage and add the "admin" user to the users_storage
*/
Error initDB() {
    Error result = create_error(0, "Success");
    for (int i = 0; i < MAX_USERS; i++) {
        if (users_storage[i] != NULL) {
            free(users_storage[i]);
        }
        users_storage[i] = NULL;
    }
    int permissions = PERMISSION_LAUNCH + PERMISSION_EDIT_USER + PERMISSION_EDIT_LAUNCHER;
    result = createUser("admin", "password", permissions);
    return result;
}

/*
Create a new User. 
- Checks for invalid permissions; it must be between 1 and 7
- Checks for duplicate users using the user name
- Creates a new user and adds it to the users_storage
- Increments the user_counter
- If the users_storage is full (ie there are MAX_USERS in the users_storage), then an error is returned 
  with a message for the UI that a user must be deleted before a new one can be created.
*/
Error createUser(char* user_name, char* password, int permissions) {
    int user_permissions = 0;
    Error result = create_error(0, "Success");
    if (permissions < 0 || permissions > 7) {
        result.code = -1;
        result.message = "Invalid permissions. Permissions must be between 0 and 7. Permissions set to 1.";
        user_permissions = 1;
    }
    else {
        user_permissions = permissions;
    }

    User* duplicate = findUser(user_name);
    if (duplicate != NULL) {
        result.message = "Duplicate user";
        result.code = -1;
        return result;
    }

    User* user = findUser(NULL);
    if (user != NULL) {
        strcpy(user->user_name, user_name);
        strcpy(user->password, password);
        user->permissions = user_permissions;
        user_counter++;
        return result;
    }
    else {
        result.message = "Out of user memory. Delete a user before creating another one.";
        result.code = -1;
        return result;
    }
}


/*
Finds a user by user name. 
- Returns NULL if the user does not exist
- Returns the User struct if the user is found
*/
User* findUser(char* user_name) {
    for (int i = 0; i < MAX_USERS; i++) {
        User * user = users_storage[i];
        if (user == NULL && user_name == NULL) {
            // found and empty user slot
            User * user = malloc(sizeof(User));
            user->index = i;
            users_storage[i] = user;
            return user;
        }
        if (user != NULL && user_name != NULL) {
            if (strcmp(user->user_name, user_name) == 0) {
                return user;
            }
        }
    }
    return NULL;
}

/*
Convenience function to print out the contents of the users_storage in a human
readable format for debugging.
*/
void printUsers() {
  for (int i = 0; i < MAX_USERS; i++) {
    User* user = users_storage[i];
    if (user != NULL) {
        printf("%i, %s, %s, %i, %i\n", i, user->user_name, user->password, user->permissions, user->index);
    }
    else {
        printf("%i, NULL\n", i);
    }
  }
}

/*
Used by readFromFile to clear the users_storage.
*/
void deleteUsers() {
    for (int i=0; i<MAX_USERS; i++) {
        if (users_storage[i] != NULL) {
            User* user = users_storage[i];
            printf("deleteUsers user_name=%s\n", user->user_name);
            free(user);
            users_storage[i] = NULL;
        }
    }
}

/*
Write the users_storage to a binary file
*/
Error saveToFile() {
    Error result = create_error(0, "Success");
    FILE *file = fopen(USER_FILE_NAME, "wb");
    if (file == NULL) {
        result.message = "Error opening file";
        result.code = -1;
        return result;
    }
    size_t element_count = 0;
    for (int i = 0; i < MAX_USERS; i++) {
        if (users_storage[i] != NULL) {
            User* user = users_storage[i];
            //printf("user_name=%s, password=%s, permissions=%i, index=%i\n", user->user_name, user->password, user->permissions, user->index);
            fwrite(user, sizeof(User), 1, file);
            if (ferror(file)) {
                perror("Error writing to file");
                result.message = "Error writing to file";
                result.code = -1;
                fclose(file);
                return result;
            } 
            element_count++;
        }
    }
    fclose(file);
    result.payload = "User data saved in a file";
    return result;
}

/*
Read the users_storage from a binary file
*/
Error readFromFile() {
    Error result = create_error(0, "Success");
    FILE *file = fopen(USER_FILE_NAME, "rb");
    if (file == NULL) {
        result.message = "Error opening file";
        result.code = -1;
        return result;
    }
    User user;
    deleteUsers();
    size_t read_size;
    int i = 0;
    int users_created = 0;
    while(1) {
        read_size = fread(&user, sizeof(User), 1, file);
        if (read_size == 0) {
            break;
        }
        else {
            createUser(user.user_name, user.password, user.permissions);
            i++;
            users_created++;
        }
    } 
    fclose(file);
    result.payload = "User data read from file.";
    return result;
}

testUsuários.c

#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include "users.h"

int main() {
  printf("InitDB: ");
  Error result = initDB();
  printf("%i, %s\n",result.code, result.message);
  printUsers();

  //create a user with bad permissions
  printf("\ncreate a user ron with bad permissions (9): ");
  result = createUser("ron", "password", 9);
  printf("%i, %s\n",result.code, result.message);
  printUsers();
 
  // create a user
  printf("\ncreate john: ");
  result = createUser("john", "pw0", 4);
  printf("%i, %s\n",result.code, result.message);
  printUsers();

  // create the same user again
  printf("\ncreate john: ");
  result = createUser("john", "pw0", 4);
  printf("%i, %s\n",result.code, result.message);
  printUsers();

  // create another user when out of users
  // Need to set MAX_USERS to 4 to trip this error condition
  printf("\ncreate mark: ");
  result = createUser("mark", "pw0", 4);
  printf("%i, %s\n",result.code, result.message);
  printUsers();

  printf("\nSaving the file: \n");
  result = saveToFile();
  printf("%i, %s, %s\n",result.code, result.message, result.payload);
  printUsers();

  printf("\nReading the file: \n");
  result = readFromFile();
  printf("%i, %s, %s\n",result.code, result.message, result.payload);
  printUsers();

  printf("\nDeleting all the users\n");
  deleteUsers();

  return(0);
}

testeRead.c

#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include "users.h"

int main() {
  printf("\nReading the file: \n");
  Error result = readFromFile();
  printf("%i, %s, %s\n",result.code, result.message, result.payload);
  printUsers();

  printf("\nRemove all the users from memory\n");
  deleteUsers();

  return(0);
}

Faça o arquivo

usermake: users.c testUsers.c
    gcc -o -g -O0 -o testUsers users.c testUsers.c -I .
    gcc -o -g -O0 -o testRead users.c testRead.c -I .

Tenho o seguinte código:

#include <stdlib.h>
#include <stdio.h>

int main() {
    void* a = malloc(10);
    printf("%p\n", a);
}

Quando compilado e executado:

clang-19 -std=c23 -fsanitize=address -g -Weverything -o test_mem.exe test_mem.c
./test_mem.exe
0x502000000010

=================================================================
==212167==ERROR: LeakSanitizer: detected memory leaks

Direct leak of 10 byte(s) in 1 object(s) allocated from:
    #0 0x55f0442625cf in malloc (/home/xxx/xxx/xxx/test_mem.exe+0xcb5cf) (BuildId: fe83f3b1cd62d6171e5d431d34ee529cce48f18f)
    #1 0x55f0442a2a68 in main /xxx/xxx/xxx/xxx/test_mem.c:8:11
    #2 0x7fa09f96fd8f in __libc_start_call_main csu/../sysdeps/nptl/libc_start_call_main.h:58:16

SUMMARY: AddressSanitizer: 10 byte(s) leaked in 1 allocation(s).

O vazamento de memória foi detectado. Ótimo!

Entretanto, se eu alterar o código para:

#include <stdio.h>
#include <stdlib.h>

void* a = nullptr;

int main() {
    a = malloc(10);
    printf("%p\n", a);
}

e compilar/executar:

clang-19 -std=c23 -fsanitize=address -g -Weverything -o test_mem.exe test_mem.c
... compiler complains about `int* a` not being static, fine...
./test_mem.exe
0x502000000010

Nenhum vazamento de memória é detectado. Fazer o int* a staticnão altera esse comportamento (o compilador apenas o relata como um aviso).

Tenho certeza de que há um "bom motivo" pelo qual o vazamento de memória não é relatado quando a variável é declarada globalmente, mas:

1. Por que isso acontece? Existe uma razão específica para esse comportamento? Poderia ser que quando uma variável é declarada no escopo global, sua memória é liberada automaticamente, mesmo quando alocada dinamicamente? Se esse for o caso, isso significa que liberar essa memória, como fazer um free(a), não é estritamente necessário?

2. Existe uma maneira de configurar o sanitizer ou compilador para detectar tais vazamentos de memória para variáveis ​​globais? Alguns sinalizadores, talvez?

Estou tentando resolver um nome de host para um endereço IP usando /etc/hostsapenas o arquivo.

Isto é, se o nome não puder ser resolvido localmente, ele deve falhar (ou seja, nenhuma solicitação DNS enviada). A maneira padrão de resolver um nome é com getaddrinfo, mas isso retornará ao DNS.

gethostent_rparece um bom candidato, pois retorna registros do arquivo de hosts locais, mas infelizmente não recebo registros IPv6, apenas IPv4.

Como posso resolver um nome para um endereço IPv4 ou IPv6 com base apenas no arquivo local /etc/hosts?

Fundo

Nota: Isso não é importante para a questão

Tenho algumas macros que agem como uma versão um pouco mais geral de atributos, que anexo a funções. Dependendo do compilador e da versão do compilador, elas se expandirão para um atributo (por exemplo, __attribute__((nonnull))) ou um aviso (por exemplo, _Pragma("message \"nonnull attribute unavailable\"")). Como as macros de atributos podem estar em qualquer ordem, isso pode levar a que sejam misturadas (por exemplo, aviso atributo atributo aviso aviso).

O resultado é que posso ter um código como o seguinte:

Amostra

#pragma message "one"
__attribute__((cold))
#pragma message "two"
__attribute__((noreturn))
#pragma message "three"
void test(void);

Emitir

Executando clang, este código de exemplo compila perfeitamente, imprimindo as três mensagens conforme o esperado.

input.c:1:9: warning: one [-W#pragma-messages]
#pragma message "one"
        ^
input.c:3:9: warning: two [-W#pragma-messages]
#pragma message "two"
        ^
input.c:5:9: warning: three [-W#pragma-messages]
#pragma message "three"
        ^

Executar gcc, no entanto, me dá um erro no segundo #pragma. Se eu comentar isso, recebo um erro no terceiro #pragma.

input.c:1:9: note: ‘#pragma message: one’
    1 | #pragma message "one"
      |         ^~~~~~~
input.c:3:9: error: expected identifier or ‘(’ before ‘#pragma’
    3 | #pragma message "two"
      |         ^~~~~~~

input.c:1:9: note: ‘#pragma message: one’
    1 | #pragma message "one"
      |         ^~~~~~~
input.c:5:9: error: expected identifier or ‘(’ before ‘#pragma’
    5 | #pragma message "three"
      |         ^~~~~~~

Com a experimentação, parece que gccnão aceita nenhuma #pragmadiretiva depois de um __attribute__.

Exemplo reproduzível

Descomentar #pragmacausa um erro reproduzível no GCC v11.4.0

__attribute__((nonnull))
// #pragma message "this is an error"
void test(void);

Pergunta

Existe alguma correção ou solução que me permita misturar as diretivas #pragmaand em , assim como permite?__attribute__gccclang

--Atualizado, veja abaixo--

Estou tentando escrever uma struct de tamanho em torno de 680 bytes para o Setor 1, Banco 2 do flash em um STM32H757XIH6. Sou bem novo nesse tipo de coisa, então estou construindo lentamente o código. Estou usando o driver STM32 HAL. O endereço deste setor é 0x08100000.

Aqui está o código:

typedef struct {
    uint32_t data_header;
    Parameter parameter[NUMBER_PARAMETERS];
    int screen_paras[MAX_SCREENS][MAX_WIDGETS];
} Persistent_data;


void save_data() {
    Persistent_data save_data;

    uint32_t data_header = DATA_HEADER;

    save_data.data_header = data_header;
    memcpy(save_data.parameter, parameter, sizeof(save_data.parameter));
    memcpy(save_data.screen_paras, screen_paras, sizeof(save_data.screen_paras));

    size_t size = sizeof(Persistent_data);
    uint32_t word_count = (size + 3) / 4; //32bit alignment
    Flash_Write(FLASH_START_ADDRESS, (uint32_t*)&save_data, word_count);
    }


HAL_StatusTypeDef Flash_Write(uint32_t address, uint32_t* data, uint32_t length) {
    HAL_StatusTypeDef status = HAL_OK;

    // Ensure address is within the flash range
    if (address < FLASH_USER_START_ADDR || (address + length) > FLASH_USER_END_ADDR) {
        return HAL_ERROR;
        }

    // Unlock the Flash
    HAL_FLASH_Unlock();

    // Erase the flash sector
    FLASH_EraseInitTypeDef eraseInitStruct = {
        .TypeErase = FLASH_TYPEERASE_SECTORS,
        .Banks = FLASH_BANK_2,
        .Sector = FLASH_SECTOR_1,
        .NbSectors = 1,
        .VoltageRange = FLASH_VOLTAGE_RANGE_3,
        };
    uint32_t sectorError = 0;

    status = HAL_FLASHEx_Erase(&eraseInitStruct, &sectorError);
    if (status != HAL_OK) {
        HAL_FLASH_Lock();
        return status;
        }

    // Write the data
     for (int i = 0; i < length / 4; i++) { // Writing 32-bit words
        status = HAL_FLASH_Program(FLASH_TYPEPROGRAM_FLASHWORD, address, data[i]);
        if (status != HAL_OK) {
            break;
            }
        address += 4; // Increment address by 4 bytes (32 bits)
        }

    // Lock the Flash
    HAL_FLASH_Lock();
    return status;
    }

Quando tento salvar o save_data (com todos os seus membros), uma falha grave é gerada a partir da linhastatus = HAL_FLASH_Program(FLASH_TYPEPROGRAM_FLASHWORD, address, data[i]);

Rastreando mais adiante, ele chega *dest_addr = *src_addr;em stm32h7xx_hal_flash.c. A partir daí, não tenho certeza de como interpretar a pilha de falhas. O próximo é<signal handler called>() at 0xffffffed

ffffffed:   Failed to execute MI command:
          -data-disassemble -s 4294967277 -e 4294967529 -- 3
          Error message from debugger back end:
          Cannot access memory at address 0xffffffec

Por favor, deixe-me saber se posso fornecer mais informações

-----Atualização 1:---- Atualizei o código para se adequar à palavra de 256 bits/32 bytes, conforme sugerido. Novos trechos de código:

typedef struct {
    uint32_t data_header;
    Parameter parameter[NUMBER_PARAMETERS];
    int screen_paras[MAX_SCREENS][MAX_WIDGETS];
} Persistent_data;

void save_data() {
    Persistent_data save_data;

    uint32_t data_header = DATA_HEADER;

    save_data.data_header = data_header;
    memcpy(save_data.parameter, parameter, sizeof(save_data.parameter));
    memcpy(save_data.screen_paras, screen_paras, sizeof(save_data.screen_paras));

    size_t size = sizeof(Persistent_data);
    uint32_t word_count = (size + 31) / 32; //32bit alignment
    Flash_Write(FLASH_START_ADDRESS, (uint32_t*)&save_data, word_count);
    }

void load_data() {

    Persistent_data load_data;
    size_t size = sizeof(Persistent_data);
    uint32_t word_count = (size + 31) / 32; //align
    Flash_Read(FLASH_START_ADDRESS, (uint32_t*)&load_data, word_count);

    if (load_data.data_header == DATA_HEADER) {
        memcpy(parameter, load_data.parameter, sizeof(parameter));
        memcpy(screen_paras, load_data.screen_paras, sizeof(screen_paras));
        }
}

HAL_StatusTypeDef Flash_Write(uint32_t address, uint32_t* data, uint32_t length) {
    HAL_StatusTypeDef status = HAL_OK;

    // Ensure address is within the flash range
    if (address < FLASH_USER_START_ADDR || (address + length) > FLASH_USER_END_ADDR) {
        return HAL_ERROR;
        }

    // Unlock the Flash
    HAL_FLASH_Unlock();

    // Erase the flash sector
    FLASH_EraseInitTypeDef eraseInitStruct = {
        .TypeErase = FLASH_TYPEERASE_SECTORS,
        .Banks = FLASH_BANK_2,
        .Sector = FLASH_SECTOR_1,
        .NbSectors = 1,
        .VoltageRange = FLASH_VOLTAGE_RANGE_3,
        };
    uint32_t sectorError = 0;

    status = HAL_FLASHEx_Erase(&eraseInitStruct, &sectorError);
    if (status != HAL_OK) {
        HAL_FLASH_Lock();
        return status;
        }


    //Write the data
     for (int i = 0; i < length / 32; i++) { // Writing 32-byte (256 bit) words
        status = HAL_FLASH_Program(FLASH_TYPEPROGRAM_FLASHWORD, address, (uint32_t)&data[i * 8]);
        if (status != HAL_OK) {
            break;
            }
        address += 32; // Increment address by 32 bytes (256 bits)
        }


    // Lock the Flash
    HAL_FLASH_Lock();
    return status;
    }

/**
 * @brief Read data from flash memory
 * @param address Start address to read (must be 256-bit aligned)
 * @param data Pointer to the buffer to store the read data
 * @param length Number of bytes to read (must be a multiple of 32)
 */
void Flash_Read(uint32_t address, uint32_t* data, uint32_t length) {
    if (address < FLASH_USER_START_ADDR || (address + length) > FLASH_USER_END_ADDR) {
        return; // Out of bounds
    }

    for (uint32_t i = 0; i < length / 32; i++) { // Reading 32-byte (256-bit) words
        // Read 32 bytes (256 bits) from flash starting at the given address
        for (uint32_t j = 0; j < 8; j++) {
            data[i * 8 + j] = *(__IO uint32_t*)(address + j * 4); // 4 bytes per uint32_t word
        }
        address += 32; // Increment address by 32 bytes (256 bits)
    }
}

Novo problema: Quando leio os dados de volta, eles não estão corretos. O data_header não corresponde. Há dados lá, mas nenhum deles está certo. Poderia ter algo a ver com a maneira como referenciei/usei ponteiros? Ou a maneira como a memória é iterada?

Atualmente, estou trabalhando na implementação do meu próprio comando "ls". Tenho me apoiado na estrutura, mas encontrei uma postagem antiga afirmando que alguns membros dessa estrutura, como d_typenão devem ser usados.

Já consegui listar os arquivos no repositório, mas quero classificá-los de acordo com seu tipo, daí o motivo da minha postagem.

Então, estou apenas me perguntando se existe alguma outra maneira além de usar o d_typeou se não é realmente errado usá-lo.

Encontrei uma coisa estranha no meu programa. Aqui estão dois exemplos

#include <stdio.h>

int main() {

    time_t t1, t2;
    t1 = 1735689614;
    t2 = 1735689600;

    printf("difftime =%d \n", difftime(t1, t2)); // difftime() return int
}

#include <stdio.h>
#include <time.h>

int main() {

    time_t t1, t2;
    t1 = 1735689614.0;
    t2 = 1735689600.0;

    printf("difftime =%f \n", difftime(t1, t2)); // difftime() return double 
}

você pode notar que #include<time.h>e o valor de retorno dedifftime()

Os difftime()dois exemplos são funções diferentes.

Eu sei que double difftime()é a função padrão de time.h (C11). Mas int difftime()de onde vêm?

É um problema muito estranho e sutil ao programar em c no vs2022. Eu mudei o padrão c para C11no vs2022. E o programa compilou OK. Eu pensei que ele usaria o double difftime()sem #inlcude<time.h>.

Embora este problema possa ser visto claramente ao usargcc

implicit declaration of function 'difftime' [-Wimplicit-function-declaration]

double difftime() int difftime()

Eu estava tentando resolver o exercício que diz

Exercício 2-7. Escreva a função rightrot(b, n) que rotaciona o inteiro b para a direita em n posições de bits.

e eu codifiquei, aqui está o código

#include <stdio.h>

int rightrot(int b, int n) {
    char i = 1;

    while (n > 0) {
        if ((b & i) == i) {
            b = b >> 1;
            b = b << 25;
            b = ~b;
            b = b >> 1;
            b = ~b;
            b = b >> 24;
        }
        else
            b = b >> 1;
        n--;
    }

    return b;
}

int main() {
    int i, j, k;

    printf("Enter number: ");
    scanf("%d", &i);
    printf("Enter rotation: ");
    scanf("%d", &j);
    
    k = rightrot(i, j);
    printf("%d\n", k);
    return 0;
}

entradas e saídas são

Enter number: 153
Enter rotation: 3
-13

153 em binário é 0000000000000000000000000010011001, então quando ele entra no loop while dentro do while ele entra no if pela primeira vez (quando n é 3), e como você vê dentro do if há 6 linhas de código com operadores bit a bit para manipular b e é isso que eu acho que essas 6 linhas devem mudar b

00000000000000000000000001001100
10011000000000000000000000000000
01100111111111111111111111111111
00110011111111111111111111111111
11001100000000000000000000000000
00000000000000000000000011001100

e então n é 2 e então outros 2 loops while devem passar, senão não vou explicar, pois o código de 6 linhas do if em si não funciona como eu quero, eu sei disso porque testei-os separadamente.

Além disso, tudo isso é porque estou rotacionando o binário, pois ele é de 8 bits e não de 32 bits.

O resultado final deve ser 51, e estou usando o Arch Linux, que é de 64 bits, totalmente atualizado, o terminal é st by suckless, o editor de texto é vim, compilei o código usando "gcc main.c -o main".

Estou usando a abordagem de divisão para converter um número inteiro unsigned int para binário. Tenho o seguinte código. No entanto, não obtenho nenhuma saída do programa após compilar e executar (só obtenho escape de nova linha).

#include <stdio.h>

/*
unsigned int is 0 or greater than 0 
convert unsigned int into binary.
*/
const int ARRAY_SIZE = 100;

void reverseCharArray(char *x, int len) {
    for (int end = len - 1, beg = 0; beg < end; end--, beg++) {
        char temp = x[beg];
        x[beg] = x[end];
        x[end] = temp;
    }

}

void convertWholeNumberToBinary(unsigned int x, char *result) {
    int i = 0;
    while (x != 0) {
        result[i] = x % 2;
        x = x / 2;
        i++;
    }
    reverseCharArray(result, ARRAY_SIZE);
}

int main() {
    char result[ARRAY_SIZE];
    convertWholeNumberToBinary(294, result); 
    // 100100110
    printf("%s\n", result);
    return 0;
}

A saída desejada é "100100110" quando a entrada é 294. Eu esperava que o stdout mostrasse "100100110". Sei que estou esquecendo de algo, mas não consigo entender no momento.