I know depending on the order of variables in struct can have different size but is this the case only for structs or it's also true in other cases? Like will something like this

int main(){

float a ;
char b;
float c;
char d;

return 0;
}

take up more memory than if I grouped it?

float a ;
float c;
char b;
char d;

Every language has tons of "quirks". By quirks, I mean small or hidden unusual behavior or scenarios you don't normally think about. C has lots of such quirks. For example, I just discovered sizeof('a') returns 4 not 1. 'a' defaults to an int. There are so many such quirks I have found but I can't even recall them now. Struct padding, signed overflow UB but unsigned wrap works, string pooling, char array allocates on the stack but char pointer allocates the string in read only memory, and so many more.

I would like a compilation if exists, of all such quirks. This would actually help in MCQ tests.

I have seen that in interviews, they can as the output of - printf("%d", printf("hello"));. Now I know what printf() returns, but most students don't go their way learning this and most institutions don't teach this thoroughly. I don't think this can be classified as a quirk but good to take a look at.

im trying to check inputs in a command line program, using windows api here (runs on command prompt or windows powershell)

if (GetAsyncKeyState(VK_UP))

playerY -= moveSpeed;

else if (GetAsyncKeyState(VK_DOWN))

playerY += moveSpeed;

else if (GetAsyncKeyState(VK_LEFT))

playerX -= moveSpeed;

else if (GetAsyncKeyState(VK_RIGHT))

playerX += moveSpeed;

but is there any way to make it more efficient, 4 system level calls for checking something this trivial is very inefficient? i tried using getkeyboardstate(), but it doesnt work in c. Tried the event driven approach, but it says that it goes through more layers and data structures which brings it back to square one even with low syscalls, im sort of confused

need help pls

Hey guys, I'm a graduate now. Just completed my B.Tech in CSE. Had a c language course in my first semester. I always liked c but couldn't move out of dsa and see how it is used in daily life. Then I later got to know there are complete operating systems running on just c. I later got curious and wanted to read the code and contribute to it. But the major issue is it feels like a xomplete different world when compared to the c I was introduced to. So wanted to ask the community, How to re-learn C?

Please suggest books or lectures or tutorials that let me understand the c we use to build things.

Thanks in advance.

This is just for a question I am not gonna switch to ints for bool. But I was wondering if using ints as boolens is reliable ethical and what not.

Example:

int main()
{
    int isRunning = 1;
    while (isRunning != 0)
    {
        {...}
    }
}

Again this is all for questions I am not actually gonna go out of my way to use it.

Sharing this short YT video from Salvatore Sanfilippo (creator of Redis) on why learning C is still valuable nowadays. The video is from a year and a half ago. I’m sharing it as source of motivation for anyone learning C right now:) Happy learning!

edit: grammar

#include <stdio.h>

void test01(){
    int b = 0x00454647;
     /* E F G */
    int a = 0x41424344;
     /* A B C D */

    // printf("%p %p\n", &b, &a);   // commented
    // volatile int b = ...;        // or this

    char *p1 = (char *)&a;
    printf("%s\n", p1);
}

Hi everyone,

I'm learning C on Windows using GCC (MinGW), and I noticed a strange behavior about stack layout.

Observation:

• When I don't take the address of b (&b) and don't use volatile, the variables a and b are not adjacent in memory. When I print the string from &a, I get DCBA followed by garbage.
• As soon as I add printf("%p", &b); or declare b as volatile, a and b become adjacent (differ by exactly 4 bytes), and I get DCBAGEF as expected.

Interestingly:

• Clang (on Windows) allocates them adjacent even without & or volatile.
• GCC on Linux also tends to put them next to each other by default.

Only GCC on Windows (MinGW) shows this "non-adjacent unless address is taken" behavior.

Questions:

1. What exactly is GCC doing during stack slot allocation in this case?
2. Why does taking the address (&) or using volatile change the layout so dramatically?
3. Is this related to some Windows ABI / MinGW specific stack alignment or optimization pass?
4. Is there any flag (besides -O0) that can make GCC behave more like Clang in terms of stack layout predictability?

I know that the C standard doesn't guarantee stack layout or variable order, but I'm curious about the implementation difference between GCC (Windows) vs Clang/GCC (Linux).

Any insight into GCC's internals (especially stack slot allocation, assign_stack_local, reload pass, etc.) would be greatly appreciated!

Thanks!

Hi y'all, I've been trying to learn C and I installed mingw using msys2.

I'm trying to compile the following code:

// hello.c
#include <stdio.h>

int main(void)
{
    printf("Hello, Windows!\n");
    return 0;
}

When running gcc hello.c -o hello.exe, I don't get any executable. I've tried reinstalling mingw, and I've also checked that I'm running the command on the same directory where the file. I also added the particular folder to Windows Defender Exclusion list but still can't get anything done. What am I doing wrong?

Edit: Got it to work by changing my terminal from Powershell to Git Bash.

Hey all! For awhile I have been interested in taking a crack at recreating some C run time libraries on Windows, and I wanted to start by trying to re create Malloc sometime soon. I have however noticed in my endeavors to look at videos and read blogs/articles about people re creating malloc, or other C runtime library functionalities, Everything online I find covering such a topic is always targeting Unix based systems. I would imagine the lack of windows targeted content on re creating these things is a sign that windows does not make it easy to do something like re create the C runtime libraries. Wanted to ask a question here to see if I'm missing something

In the following code, calling test1 doesn't provide a warning, but calling test2 does. Is there a specific reason for this behavior?

void test1(void* x);
void test2(void** x);

int main() {
    int* x1;
    int** x2;

    test1(x1); // ok
    test2(x2); // warning "incompatible pointer type"
}

Edit: I think some people don't understand. I'm asking why void** doesn't match with other x**, not why it doesn't work exactly the same as void*.

🚀 LightBase

Ultra-performance, bare-metal local development runtime bridge and persistence engine built for high-compute applications.

LightBase decouples heavy disk and outbound network I/O into a standalone, multi-threaded C background daemon, communicating asynchronously with an API gateway over high-speed Linux Unix Domain Sockets (UDS).

🏗️ Architecture Layout

LightBase eliminates high-level framework overhead, garbage collection cycles, and process-blocking runtime constraints by decoupling tasks into independent layer boundaries.

graph TD
    UI[HTML5 Control Center UI] <--> PY[Python Gateway Bridge Server]
    PY -- "Binary TLV Frame Stream (/tmp/lightbase.sock)" --> CORE[C-CORE ASYNC THREAD POOL]
    
    subgraph "C-CORE (libcore.so)"
    CORE --> R1[Arena-Powered SQL Engine]
    CORE --> R2[Stack-Isolated OpenSSL TLS]
    CORE --> R3[Kernel /proc Ring Log Storage]
    CORE --> R4[Database Catalog Scanner]
    end

Layer Responsibilities

• Frontend UI Layer: A lightweight development client executing async network operations back and forth.
• API Gateway Layer: A zero-dependency Python routing engine acting as an IPC proxy gateway.
• Native Systems Core: A high-speed, bare-metal C shared engine processing dynamic allocations, filesystem transactions, and socket forging loops on detached POSIX background threads.

🚀 Core Studio Module Suite

🌐 Module 1: Bare-Metal Environment Manager

Tracks application environments (Development, Staging, and Production) dynamically inside isolated runtime boundaries.

• Atomic Remapping Swaps: Eliminates sluggish filesystem configuration lookups by pre-allocating an EnvironmentBlock structure directly within a dedicated MemoryArena. Context switches occur in under 1μs via thread-safe atomic pointer reassignments.
• Fallback Safety Paths: System state transitions are fully guarded against uninitialized pointer exceptions, ensuring backup file parameters handle initial transaction states safely.

🧪 Module 2: Cryptographic API Testing Studio

Provides bare-metal HTTP engine request assembly and transaction benchmarking.

• Wire Packet Serialization: Leverages stack-allocated sequence spaces to assemble raw wire payloads (GET, POST, PUT, DELETE) with exact specification alignment.
• Memory Security: Replaces vulnerable variable concatenation with explicit length-bounded tracking (strncat), preventing string overflows when importing large custom data tokens.

🗄️ Module 3: Log-Structured Database Explorer

Powers interactive sidebar schema catalog visualizers and data grids.

• Catalog Data Harvesting: Bypasses table-scanning bottlenecks by executing targeted schema scans directly against the internal engine catalog (sqlite_master).
• Tele-Profiling: Measures precise VM bytecode query times using high-resolution monotonic hardware timers (clock_gettime).

🗄️ Append-Only Ring Buffer Telemetry Storage

Ensures high-throughput execution tracking without destroying flash storage sectors.

• Static File Sizing: Pre-allocates a fixed array block file footprint on disk exactly once during system boot, guaranteeing predictable allocation.
• Wrap-Around Bit Algebra: Sequences incoming snapshots using sliding timestamp indexes. When the tracking pointer reaches limits (1024 slots), it wraps back to slot 0 instantly.

📊 Performance Benchmarks

LightBase delivers sub-millisecond core processing speeds by bypassing the local network routing stack:

• Local Database Transaction: ~990.20 μs ($< 1\text{ ms}$ bare-metal execution)
• Total IPC Roundtrip Gateway Latency: ~1.203 ms (Inclusive of Python decoding and HTTP transport)
• Outbound HTTP Network Socket Request: Variable based on distance, wrapped with microsecond-accurate tracking via CLOCK_MONOTONIC.

🛠️ Compilation & Installation

Prerequisites

Ensure your host machine runs a modern Linux kernel with cmake, gcc, and uv:

sudo apt update && sudo apt install cmake build-essential

1. Build the Production Core Library

LightBase employs an out-of-source CMake build pipeline with Link-Time Optimizations (-O3 -march=native -flto -s):

cd core
mkdir -p build_release && cd build_release

# Configure and build the target layout
cmake -DCMAKE_BUILD_TYPE=Release ..
cmake --build . --target install

Assets generated:

• Public Header: dist/include/engine.h
• Shared Binary: dist/lib/libcore.so

2. Boot the Intermediary Python Gateway

cd ../../bridge
/usr/bin/uv run python python_bridge.py

The C-Core instantly carves out a high-speed memory socket at /tmp/lightbase.sock upon initialization.

🧠 Memory Design & Safety Assertions

• Header Symbol Ordering: Enforces a strict structure order: macro directives first, raw packed structural records second, and export function interfaces last to ensure top-down layout translation.
• Translation Scope Reductions: Centralizes cross-module variables within a shared master header file to keep dependencies clear.
• Thread Race Protection: Active server file descriptors pass explicitly into separate heap memory pools (malloc) at worker thread creation, isolating context pointers from stack invalidation faults.

📄 License

Licensed under Apache License 2.0

New projects and games made in Unigine. C is a primary form of coding in Unigine

I’ve been comparing GCC 15/trunk and Clang on small 32-bit bit-vector expressions, and I’ve found a few proven equivalences where one compiler canonicalizes a pattern while the other does not. The optimized forms typically yield modest scalar speed improvements.

Two examples:

uint32_t is_nonzero = (x | (0u - x)) >> 31;

Clang folds this to `x != 0`, producing a clean `test` / `setne` sequence on x86. GCC, including trunk, currently emits a more literal `neg/or/shr`-style sequence.

uint32_t carry64 = (uint32_t)((((uint64_t)x) + y) >> 32);

uint32_t carrycmp = (x + y) < y; // or < x

return carry64 == carrycmp;

This is mathematically always true for 32-bit unsigned `x` and `y`.

Clang folds the `(x + y) < x` spelling to a constant true result, but not the `(x + y) < y` spelling on the targets I tested. GCC currently does not fold either spelling.

My questions are:

- Do maintainers generally appreciate reports for small peephole/canonicalization misses like these?

- Is there a rough threshold where a pattern is considered too niche to justify the compile-time cost or added middle-end complexity?

- Is it better to file these as separate issues, or group related identities into one report?

I can provide minimal reproducers, Z3 proofs, and benchmark data if useful.

Note: I used AI to clean up the wording of this post. The compiler testing, proofs, and benchmark data were generated by my own scripts.

I was following this tutorial, which is supposed to be "modern" with "up to date" features and practices.

However, I very quickly stumbled upon this piece of code:

auto unsupportedLayerIt = std::ranges::find_if(requiredLayers,
                                               [&layerProperties](auto const &requiredLayer) {
                                               return std::ranges::none_of(layerProperties,
                                                                           [requiredLayer](auto const &layerProperty) { return strcmp(layerProperty.layerName, requiredLayer) == 0; });
                                               });

I'm just stunned. I can't believe cpp people actually write code like this? This just seems insane to me and I kind of hate it.

So I have 2 questions:

1. Am I in the wrong here? Should I just accept that this is normal and the industry standard and get over it? Or is it just absurd?
2. If it IS absurd, does anyone have any recommendations for other resources I could learn Vulkan from? I'd prefer if it was just straight up in C or at least very basic features of C++?