Career upgrade: Learn practical AI skills for better jobs and higher pay.
Level up
PracticeVideosBlogFlashcardsEspañol
All Practice Exams

100+ Free C CLP Practice Questions

Pass your C++ Institute C Certified Professional Programmer (CLP) exam on the first try — instant access, no signup required.

✓ No registration✓ No credit card✓ No hidden fees✓ Start practicing immediately
Not published Pass Rate
100+ Questions
100% Free
1 / 100
Question 1
Score: 0/0

Which IEEE-754 special bit pattern represents 'Not a Number'?

A
B
C
D
to track
Same family resources

Explore More C++ Institute Certifications

Continue into nearby exams from the same family. Each card keeps practice questions, study guides, flashcards, videos, and articles in one place.

C++ Institute C Certified Associate Programmer (CLA-11-03)

Practice Questions

C++ Institute C Certified Entry-Level Programmer (CLE-10-01)

Practice Questions

C++ Institute Certified Associate Programmer (CPA-21-02)

Practice Questions

C++ Institute Certified Entry-Level Programmer (CPE-20-01)

Practice Questions

C++ Institute Certified Professional Programmer (CPP-22-02)

Practice Questions
2026 Statistics

Key Facts: C CLP Exam

55

Score-weighted Items

C++ Institute CLP-12-01 syllabus

65 min

Exam Duration

C++ Institute CLP-12-01 syllabus

70%

Passing Score (normalized)

C++ Institute CLP-12-01 syllabus

$325

Exam Fee (USD)

C++ Institute / Pearson VUE

8

Syllabus Blocks

Official CLP-12-01 syllabus

CLA

Recommended Prereq

C++ Institute prerequisites

C Certified Professional Programmer (CLP-12-01) is a 55-question, 65-minute proctored exam delivered by Pearson VUE. Passing score is 70% normalized and the exam fee starts at $325 USD. CLP tests advanced C (NOT C++) systems-programming fluency: K&R/C89/C99/C11/C17 evolution, stdarg.h variadic functions, vsnprintf, POSIX low-level I/O (open, read, fcntl, ioctl), qsort and bsearch, alignment and flexible array members, wchar_t/char16_t/char32_t, fork/exec/wait, pthreads and C11 threads.h, _Atomic and memory_order, IEEE-754 layout and Kahan summation, BSD sockets with htons/getaddrinfo/select, setjmp/longjmp, restrict, strict aliasing, and undefined behavior categories. Recommended after CLA.

Sample C CLP Practice Questions

Try these sample questions to test your C CLP exam readiness. Each question includes a detailed explanation. Start the interactive quiz above for the full 100+ question experience with AI tutoring.

1In ANSI C (C89), which feature was introduced that was NOT present in K&R C?
A.The // single-line comment
B.Function prototypes with parameter type declarations
C.Variable-length arrays (VLAs)
D.The _Bool type
Explanation: ANSI C / C89 standardized function prototypes — declarations that include parameter types — replacing the older K&R style where parameter types appeared in a separate declarator list after the parenthesis. Prototypes enable compile-time argument checking and implicit conversions of arguments at the call site.
2Which of the following is a C11-only keyword?
A.restrict
B.inline
C._Generic
D.register
Explanation: _Generic was added in C11 and supports compile-time type-based selection of expressions; it is the foundation of type-generic macros such as the cbrt macro in <tgmath.h>. restrict and inline were added in C99; register dates back to K&R C.
3In C, the trigraph sequence ??= is replaced by which character during preprocessing?
A.#
B.[
C.{
D.\
Explanation: Trigraphs are three-character sequences that translate to a single character during preprocessing. ??= becomes # (used in #include, #define). Other trigraphs include ??( -> [, ??) -> ], ??< -> {, ??> -> }, ??/ -> \. Trigraphs were added because some early ISO 646 keyboards lacked these characters. C23 removes trigraphs.
4Which of these declarations was valid in K&R C but is now considered obsolete?
A.int main(void) { return 0; }
B.int sum(a, b) int a, b; { return a + b; }
C.int *p = NULL;
D.static const int N = 10;
Explanation: The K&R-style function definition lists parameter names in the parentheses and their types in a separate declaration list before the function body. ANSI C deprecated this style in favor of prototypes. C23 finally removes K&R declarations from the language.
5What is the difference between an empty parameter list f() and f(void) in modern C?
A.They are identical
B.f() means 'unspecified parameters' (legacy K&R), f(void) means 'no parameters'
C.f() means 'no parameters', f(void) is a syntax error
D.f(void) is C++ only
Explanation: In a function declaration, f() specifies an unspecified number of parameters (a holdover from K&R C) and disables argument-count checking by the compiler. f(void) explicitly states zero parameters and the compiler will reject any argument. Always prefer f(void) in declarations to get type-safety. C23 changes f() to mean f(void).
6Which header was added in C11 to provide alignment specifiers and queries?
A.<align.h>
B.<stdalign.h>
C.<aligned.h>
D.<stdaligned.h>
Explanation: <stdalign.h> provides macros that expand to the C11 keywords _Alignas (request specific alignment) and _Alignof (query alignment requirement). The header lets code use the lowercase forms alignas and alignof.
7Why was the gets() function removed in C11?
A.It was inefficient
B.It is unsafe — it cannot detect or prevent buffer overflow because no buffer size is passed
C.It conflicted with C++
D.It was never standardized
Explanation: gets() reads a line from stdin into a caller-supplied buffer with no information about the buffer's size, so any input longer than the buffer overruns it — a classic exploit vector. C11 removed gets() entirely. Use fgets(buf, sizeof buf, stdin) or, in C11 Annex K, gets_s().
8What does the digraph <% expand to during translation?
A.[
B.{
C.#
D.<<
Explanation: Digraphs are token-level alternatives: <% -> {, %> -> }, <: -> [, :> -> ], %: -> #, %:%: -> ##. Unlike trigraphs, digraphs are processed during tokenization (not text replacement), so they cannot appear inside strings or character constants.
9Which of the following is true about the _Noreturn function specifier (C11)?
A.The function must return void
B.It tells the compiler the function never returns to its caller (e.g., abort, exit, longjmp)
C.It makes the function inline
D.It prevents the function from being called
Explanation: _Noreturn (or noreturn from <stdnoreturn.h>) indicates the function does not return — typical examples are abort(), exit(), _Exit(), longjmp(), and thrd_exit(). The compiler can suppress dead-code warnings after a call and may optimize differently. The function may still have any return type (often void), but if execution actually returns the behavior is undefined.
10In C, which storage-class specifier was given new semantics by C99 to allow inline definitions across translation units?
A.static
B.extern
C.inline
D.auto
Explanation: C99 introduced 'inline' with rules tailored for C: a translation unit may contain an inline definition that the compiler can expand inline, but exactly one external definition (often produced by 'extern inline' or by repeating the declaration without inline) must exist somewhere for the linker. The semantics differ from C++.

About the C CLP Exam

The C++ Institute CLP exam (CLP-12-01) validates advanced C language skills — note this is the C credential, NOT the C++ CPP. Topics include applied evolution of C standards, variadic functions and macros, low-level I/O via POSIX/WinAPI, memory and string handling with qsort/bsearch and wide characters, process and thread management with C11 threads.h and POSIX pthreads, IEEE-754 numerical computations, BSD network sockets, and specialized considerations like setjmp/longjmp, the strict aliasing rule, restrict, and undefined behavior.

Questions

55 scored questions

Time Limit

65 minutes

Passing Score

70% normalized

Exam Fee

$325 (C++ Institute / OpenEDG / Pearson VUE)

C CLP Exam Content Outline

14.5%

Applied Evolution of C Programming

Historical C standards (K&R, ANSI/C89, C99, C11, C17), obsolete vs modern function declarations, trigraphs and digraphs, default argument promotions, and C11 keywords (_Alignas, _Atomic, _Generic, _Noreturn, _Static_assert, _Thread_local).

9%

Variadic Functions and Macros

stdarg.h macros (va_list, va_start, va_arg, va_end, va_copy), implementing printf-style functions with vsnprintf, default argument promotions, and variadic macros with __VA_ARGS__.

13%

Fundamentals of Low-Level I/O

POSIX vs WinAPI vs API/ABI distinctions, system calls (open, read, write, close), fcntl flags including O_NONBLOCK, ioctl device control, blocking vs non-blocking I/O, EINTR handling, and stdio buffering vs raw descriptors.

16%

Memory and String Handling

qsort and bsearch comparators, malloc/calloc/realloc/free idioms and double-free defense, alignment and aligned_alloc (C11), flexible array members, pool/slab allocators, wide characters (wchar_t, char16_t, char32_t), mbstowcs/wcstombs and locale, and secure string functions.

9%

Process and Thread Management

Process vs thread distinctions, fork/exec/wait, POSIX pthreads (create, join, mutex, cond), C11 threads.h primitives (thrd_*, mtx_*, cnd_*), _Thread_local storage, race conditions, deadlocks, lock ordering, and reentrancy with async-signal-safety.

11%

Numerical Types and Computations

IEEE-754 binary32/binary64 layout, NaN and infinity bit patterns, DBL_EPSILON and float-equality pitfalls, fenv.h with FENV_ACCESS, Kahan compensated summation, fmod vs the %% operator, atomics with memory_order, and multi-precision arithmetic strategies.

13%

Network Socket Programming

BSD sockets API (socket, bind, listen, accept, connect, send, recv), SOCK_STREAM vs SOCK_DGRAM, byte-order conversion with htons/htonl, getaddrinfo, SO_REUSEADDR and SO_REUSEPORT, TCP framing requirements, and I/O multiplexing with select/poll/epoll.

14.5%

Specialized Programming Considerations

const vs volatile semantics, setjmp and longjmp non-local jumps, complex declarations and function-pointer tables, strict aliasing rule and type-punning via memcpy, restrict keyword, undefined vs unspecified vs implementation-defined behavior, MISRA C, signed overflow, and opaque pointers / PIMPL idiom.

How to Pass the C CLP Exam

What You Need to Know

  • Passing score: 70% normalized
  • Exam length: 55 questions
  • Time limit: 65 minutes
  • Exam fee: $325

Keys to Passing

  • Complete 500+ practice questions
  • Score 80%+ consistently before scheduling
  • Focus on highest-weighted sections
  • Use our AI tutor for tough concepts

C CLP Study Tips from Top Performers

1Memorize the C-standards timeline and what each version added: ANSI/C89 (prototypes, void, enums), C99 (//, VLA, _Bool, restrict, designated initializers, inline), C11 (_Generic, _Atomic, _Noreturn, _Thread_local, threads.h optional), C17 (bug-fix only).
2Drill the variadic-function pattern: va_list ap; va_start(ap, last_named); va_arg(ap, T); va_end(ap). Remember default argument promotions: char/short -> int, float -> double, and that the last named parameter must NOT be a promoted type.
3Know POSIX low-level I/O return-value rules cold: open returns fd or -1; read returns >0 bytes, 0 EOF, -1 error; non-blocking returns -1 with errno EAGAIN/EWOULDBLOCK. Wrap signal-prone calls in 'while (r==-1 && errno==EINTR)' loops.
4Practice the qsort comparator: int cmp(const void *a, const void *b). Avoid the 'a-b' overflow trap by writing '(*pa > *pb) - (*pa < *pb)'. bsearch needs the array sorted with the SAME comparator.
5Be fluent with IEEE-754 binary32/binary64 layouts: 1+8+23 (bias 127) and 1+11+52 (bias 1023). NaN = max-exp + nonzero-frac; Inf = max-exp + zero-frac. Never compare floats with ==.
6Learn the strict aliasing rule and how to type-pun safely with memcpy. Build C with -fstrict-aliasing -O2 and test under -fsanitize=address,undefined to catch UB early.
7Master the BSD socket sequence: socket -> bind -> listen -> accept (server) and socket -> connect (client). Wrap port/addr in htons/htonl. Use getaddrinfo, never deprecated gethostbyname.
8Walk through the goto-cleanup idiom: paired labels in reverse-acquisition order release resources cleanly. The Linux kernel uses it everywhere — recognize it on the exam.

Frequently Asked Questions

What is on the C++ Institute CLP exam?

CLP-12-01 tests advanced C language skills — note that despite the C++ Institute branding, CLP is the C credential, not C++. Eight blocks are covered: applied evolution of C (K&R/C89/C99/C11), variadic functions with stdarg.h, low-level POSIX/WinAPI I/O, memory and string handling including qsort/bsearch and wide characters, process and thread management with pthreads and C11 threads.h, numerical types and IEEE-754, BSD network sockets, and specialized considerations like setjmp/longjmp, the strict aliasing rule, restrict, and undefined behavior. Many items present a short C code listing and ask what the program prints or which line invokes undefined behavior.

How long is the CLP exam and how many questions does it have?

The CLP-12-01 exam contains 55 score-weighted questions delivered in 65 minutes, with about 10 additional minutes for the non-disclosure agreement and tutorial. Items are single-choice and multiple-choice, and many present a short C code listing and ask what the program prints or which line invokes undefined behavior.

What is the passing score for CLP?

The CLP-12-01 passing score is 70% normalized across the eight syllabus blocks. Because items are score-weighted, the raw question count needed to pass varies; treat 80%+ on practice tests as your safety margin before scheduling the live exam.

How much does the CLP exam cost?

The current C++ Institute CLP-12-01 exam fee starts at USD 325 for a single attempt, with bundle pricing around USD 375 that includes one paid retake. Pricing is set by C++ Institute and OpenEDG and can vary by region or promotional voucher.

What are the prerequisites for CLP?

There are no formal prerequisites to register for CLP-12-01, but C++ Institute strongly recommends holding the CLA (C Certified Associate Programmer) credential first. CLA covers the C language fundamentals; CLP assumes you already know pointers, arrays, structures, the preprocessor, and file I/O, and focuses on advanced systems-programming topics, threads, sockets, and undefined behavior.

Is CLP a C language or C++ exam?

CLP is a C language exam — despite being administered by the C++ Institute, the credential validates advanced ANSI/ISO C skills. The C++ counterpart at this level is the CPP (CPP-22-02). CLP candidates are expected to write idiomatic C99/C11/C17 with no C++ features. The exam covers the C standard library, POSIX system calls, BSD sockets, and pthread/C11 threading.