The C source file (.c)

The basics

What is a C file?

Anatomy

What's inside a C file

A C file is a list of declarations and function definitions. Lines starting with # are instructions to the preprocessor, which runs first. Here is a short but complete program that prints a temperature table, part by part.

/* table.c: print a Celsius to Fahrenheit table */
#include <stdio.h>
#include <stdlib.h>

#define STEP 20

static double to_fahrenheit(double celsius);

int main(void)
{
    for (int c = 0; c <= 100; c += STEP) {
        printf("%3d C = %5.1f F\n", c, to_fahrenheit(c));
    }
    return EXIT_SUCCESS;
}

static double to_fahrenheit(double celsius)
{
    return celsius * 9.0 / 5.0 + 32.0;
}

1. 1/* table.c: … */

   A comment

   /* … */ comments can span several lines and don't nest. Since C99, // starts a comment that runs to the end of the line.

2. 2#include <stdio.h>

   An include

   The preprocessor pastes in the whole header file at this point. stdio.h declares printf; stdlib.h defines EXIT_SUCCESS. Angle brackets search the system's include folders; quotes, as in #include "stats.h", search next to this file first.

3. 3#define STEP 20

   A macro

   A text substitution: every STEP below becomes 20 before the compiler proper sees the code. By convention macro names are in capitals.

4. 4static double to_fahrenheit(double celsius);

   A prototype

   Declares the function before it's used, so the compiler can check each call. The body comes later. static keeps the name private to this file.

5. 5int main(void)

   The entry point

   Every C program starts in main. (void) means it takes no arguments; the other standard form is int main(int argc, char *argv[]), which receives the command-line arguments.

6. 6{ … }

   A block

   Braces group statements. Indentation means nothing to the compiler; the braces and semicolons do.

7. 7for (int c = 0; c <= 100; c += STEP)

   A loop with a local variable

   c exists only inside the loop. Every variable has a fixed type (int, double, char…) that can't change.

8. 8printf("%3d C = %5.1f F\n", …);

   Formatted output

   %3d prints an integer in 3 columns and %5.1f a number with one decimal. The format must match the arguments: C doesn't check at run time, though -Wall makes compilers warn.

9. 9return EXIT_SUCCESS;

   The exit status

   What main returns goes back to the shell or script that ran the program. 0, or EXIT_SUCCESS, means it worked.

10. 10static double to_fahrenheit(double celsius) { … }

    A function definition

    The body that the prototype promised. Arguments are passed by value: the function gets a copy of c, converted to double.

Under the hood

How to compile and run a C file

# one file: compile and link in one step
cc -Wall -Wextra -std=c17 table.c -o table
./table

# several files: compile each to an object file, then link them
cc -Wall -Wextra -std=c17 -c main.c      # makes main.o
cc -Wall -Wextra -std=c17 -c stats.c     # makes stats.o
cc main.o stats.o -lm -o report          # links them, plus the maths library

Conventions

The files that travel with a .c file

Versions

C standards: C89 to C23

Related formats

.c vs .cpp, .h and other neighbours

Troubleshooting

C compile errors people hit most, and what they mean

How to

How to open and edit a C file

Security

Is it safe to open a C file?

Free downloads

Sample C files to download

Free sample C files for testing compilers, editors, syntax highlighting, code viewers and upload filters. All but one compile with GCC and Clang using -Wall -Wextra -std=c17 without a single warning; sample-c23.c needs C23 mode, and sample-compile-error.c fails on purpose.

Loading…

What's inside sample-program.c

The file is commented: open it in a text editor and each numbered comment marks one of these parts. Compile it with cc -Wall -Wextra -std=c17 sample-program.c -o sample-program and run ./sample-program to see a stock report.

1. Comments 1 and 2: includes and a macro

   Three standard headers, then ARRAY_LEN, a macro that counts the elements of an array with sizeof.

2. Comments 3 and 4: a struct and a table

   A typedef struct for a shop item and a static const array of five fictional items, private to the file.

3. Comments 5 and 6: functions and pointers

   A function that takes a pointer to a constant item, and a comparison function for qsort that converts const void * pointers back to items.

4. Comment 7: main

   int main(int argc, char *argv[]), the form that receives command-line arguments.

5. Comment 8: reading an argument safely

   strtol with full error checks, so ./sample-program abc prints a usage message and exits with status 1 instead of treating the text as 0.

6. Comment 9: heap memory

   malloc with a NULL check, an array of pointers sorted with qsort, and the matching free.

7. Comments 10 and 11: output and the exit status

   printf field widths that line up a table, and return EXIT_SUCCESS, which tells the shell the program worked.

All sample C files

• Commented sample program

  sample-program.c · 3.9 KB (4,038 bytes)

  A complete program that prints a sorted stock report: includes, a macro, a struct, pointers, qsort, malloc and free, safe argument parsing with strtol, and formatted output, with numbered comments explaining each part.

  • Checking compilers, linters and syntax highlighters
  • Teaching the parts of a C program
  DownloadOpen

• Hello world with Windows (CRLF) line endings

  sample-hello.c · 476 bytes

  The classic first program, saved with CRLF line endings on purpose. It compiles everywhere, which makes it a quick test of editors, diffs and Git's line-ending settings.

  • Line-ending handling in editors, Git and CI
  • A minimal compile test
  DownloadOpen

• UTF-8 string literals

  sample-utf8.c · 1.9 KB (1,930 bytes)

  Greetings in seven scripts, from Latin to Japanese, plus symbols and emoji. For each one it prints the size in bytes (strlen) and the number of characters, counted by hand from the UTF-8 bytes.

  • Testing source encoding in compilers, especially MSVC with and without `/utf-8`
  • Showing why `strlen` counts bytes, not characters
  DownloadOpen

• C23 features

  sample-c23.c · 1.6 KB (1,673 bytes)

  bool and nullptr as keywords, binary literals, digit separators, typeof, [[nodiscard]] and a message-less static_assert. Compiles with -std=c23 (GCC 14 and later, Clang 18 and later) and fails under -std=c17.

  • Checking which C standard a compiler or build uses
  • Syntax highlighters and parsers that need to understand C23
  DownloadOpen

• Deliberate compile errors (does not compile)

  sample-compile-error.c · 923 bytes

  Clearly labelled, and broken on purpose: an undeclared identifier, a call to an undeclared function and a missing semicolon, each with its fix in a comment.

  • Testing how editors, CI logs and build servers show errors
  • Error parsers and problem matchers
  DownloadOpen

• 100 KB C file

  sample-100kb.c · 100 KB (102,400 bytes)

  A table of the first 13,330 prime numbers and a program that checks every one, padded with a comment to exactly 102,400 bytes. Compiles cleanly and runs.

  • Upload and size-limit tests
  • Editor and syntax-highlighter performance
  DownloadOpen

Ways to test with them

• Compiler and standard: sample-c23.c compiles only in C23 mode, so it shows at once whether a toolchain or build file sets the standard you expect.
• Encoding: compile sample-utf8.c with MSVC with and without /utf-8 and compare the output with the comments in the file.
• Line endings: commit sample-hello.c to a Git repository and check whether your core.autocrlf or .gitattributes settings convert it.
• Error reporting: build sample-compile-error.c in your CI or editor; GCC and Clang should each report the problems marked A, B and C.
• Upload limits: sample-100kb.c is exactly 102,400 bytes, for testing a limit at the boundary.

Free to use for testing, teaching and demos, commercially or not, with no attribution needed. A link back to this page is always appreciated.

Questions

C files, frequently asked