C17 Exam Guide: What to Study, How to Practise, and How to Check Your MSVC Setup
C17 is best approached as a C language standard and compiler-configuration assessment rather than a memorization exercise. The available official material supports preparation around required C11 and C17 features, source-file mode, compiler switches, SDK prerequisites, and known implementation boundaries in Microsoft Visual C++. This guide is for C developers, C++ developers maintaining C code, and engineers working in Visual Studio who need to decide whether their preparation should focus on language semantics, build configuration, or both. No official exam blueprint, score, duration, price, language list, or delivery format is supplied here, so those details must be confirmed with the exam provider before scheduling.
What C17 preparation should validate
A sound C17 preparation plan should show that you can read, explain, configure, and troubleshoot C17 code in the documented MSVC environment. The supplied sources do not publish an official C17 exam objective list, so the skills below are a practical study scope derived from the supported language features and setup requirements, not a claimed vendor blueprint.
Recognize the language standard in use
You should be able to distinguish C source compilation from C++ compilation and identify whether a project is using ISO C11 or ISO C17. In Visual Studio, the C Language Standard property applies when the language is C, while the C++ Language Standard property applies when the language is C++. A .c extension defaults to C; a .cpp extension defaults to C++.
Practise explaining why the file extension matters before examining the code itself. A source file containing familiar C syntax can still be compiled under an unintended language mode, producing misleading diagnostics or hiding the behavior you intended to test. When a project does not use a .c extension, know that Compile as C code (/TC) can explicitly select C compilation.
Explain the required C11 and C17 features
The MSVC announcement identifies required support for _Pragma, restrict, _Noreturn and , _Alignas, _Alignof and , _Generic and , and _Static_assert. Preparation should cover what each feature expresses, where its corresponding header is needed, and how it changes the way a program communicates intent.
Do not study the feature names as an isolated list. For each one, write a small example, describe the compiler-visible effect, and identify the portability or maintenance question it raises. For example, _Static_assert checks an assumption during compilation; _Alignas expresses an alignment requirement; _Generic selects an association based on a controlling expression's type; and restrict communicates an aliasing promise that affects optimization assumptions.
Configure a build that actually uses C17
A candidate should be able to set the project to ISO C17 (2018) Standard (/std:c17), select a suitable Windows SDK, and ensure that the source is compiled as C. The documented Visual Studio path is Project Property Pages, Configuration Properties, General, followed by the C Language Standard setting and the Windows SDK Version setting.
Treat configuration as a testable skill. After changing the settings, inspect the effective project configuration, compile a .c file containing a C17 feature, and record the compiler command or diagnostic output. This prevents a common preparation error: believing that a property was changed when the active configuration, platform, or file type still selects different behavior.
Understand conformance boundaries
The official material says that all required C11 and C17 features are supported, while C11 optional features are not currently supported. It also states that complex numbers are not currently planned and that their absence is enforced with the appropriate feature-test macros. These boundaries belong in revision notes because a standards question may test what is required, optional, or unavailable.
C17 should not be treated as a completely separate feature set from C11 in this MSVC context. The announcement describes C17 as essentially a bug-fix release of ISO C, with relevant defect reports adopted, and says the C11 support already includes those relevant defect reports. The documented difference between the C11 and C17 versions is the value of __STDC_VERSION__: 201112L for C11 and 201710L for C17.
Who should use this study plan
This guide is most useful for candidates whose work involves C source, MSVC project files, or mixed C and C++ repositories. It is less suitable as a substitute for a general algorithms, operating-systems, or C++ language course because the supplied evidence is specifically about C11 and C17 support in the Microsoft toolchain.
C developers moving into Visual Studio
If your existing C knowledge comes from GCC or Clang, make compiler configuration your first diagnostic exercise. The language concepts may be familiar, but the project must select C rather than C++, use the C language standard property, and have the required SDK and runtime support. Build the same small source file under your normal compiler and MSVC, then investigate differences instead of assuming that a successful build proves identical behavior.
C++ developers maintaining C components
C++ experience helps with project navigation and build systems, but it can also conceal gaps. C and C++ are selected differently in Visual Studio, and a .cpp file does not test C17 mode. Create deliberately named .c files and verify that the project is compiling them as C. Revise the C-specific keywords, headers, type-selection behavior, alignment rules, and compile-time assertions without relying on C++ equivalents.
Build and release engineers
Build specialists should concentrate on reproducibility. Document the selected Visual Studio version, Windows SDK Version, C Language Standard, Compile As setting, and preprocessor behavior. A developer may have a working local build while a clean machine lacks the required SDK or updated Universal C Runtime. Your preparation is complete only when you can explain which setting controls each part of the build and how you would prove it.
Candidates using an exam label without a published blueprint
If C17 is a catalogue label on the site where you found this guide, do not infer official scope from the label alone. The supplied sources do not identify an exam sponsor, certification level, prerequisites, registration workflow, passing score, question count, time limit, languages, or retirement status. Confirm those items with the provider before paying or scheduling; use the technical scope here as a preparation baseline, not as evidence of an official blueprint.
Set up a reliable practice environment
Use a supported Visual Studio installation and a Windows SDK that meets the documented minimum before spending time diagnosing code. Microsoft lists Visual Studio 2019 version 16.8 or later and Windows SDK 10.0.20348.0 (version 2104) or later as prerequisites, and recommends the latest version available for the best support.
Verify the installed components
If Visual Studio is not installed, include the Desktop development with C++ workload and use the Individual Components tab to select Windows 10 SDK (10.0.20348.0) or later, or the latest Windows 11 SDK. If Visual Studio is already installed without the required SDK, open Visual Studio Installer, choose Modify next to the installed version, open Individual Components, select the SDK, and apply the change.
Keep a short environment record. Note the Visual Studio version, selected SDK, project type, active configuration, and whether the source file is .c. This record turns vague errors into controlled troubleshooting. It also makes it easier to rebuild the exercise after an update or on another machine.
Select the C17 properties
In the project Property Pages dialog, set Windows SDK Version on Configuration Properties > General to 10.0 (latest installed version) or to the specific SDK version installed. Set C Language Standard to ISO C17 (2018) Standard (/std:c17). If the project has C++ files, do not assume the C++ Language Standard property changes the behavior of the C files.
If a file is not using the .c extension, open Configuration Properties > C/C++ > Advanced and set Compile As to Compile as C code (/TC). Make one change at a time and rebuild. A controlled sequence makes it clear whether an error came from the language mode, SDK selection, source code, or another project setting.
Check the conforming preprocessor
The documented support requires an updated Universal C Runtime and Windows SDK to work properly with the conforming preprocessor (/Zc:preprocessor). The two new C compiler switches, /std:c11 and /std:c17, imply /Zc:preprocessor. If a legacy source file depends on the traditional character-based preprocessor, the announcement says that /Zc:preprocessor- must be passed explicitly when using C11 or C17.
Study this as a compatibility decision rather than a switch to memorize. Ask what the source expects, which preprocessor mode the C17 switch selects, and whether the correct fix is to modernize the source rather than preserve a legacy dependency. Test macros that use token combinations, conditional compilation, and standard headers so that your diagnosis is based on observed compiler behavior.
Separate editor feedback from compiler support
The MSVC announcement says IntelliSense highlighting is available natively for the supported features when a .c file extension or /TC is used, but that highlighting is currently available for keywords and not for macros introduced by standard headers. Do not use missing editor colorization as proof that the compiler lacks a feature.
Compile a focused file and read the actual diagnostic. This distinction matters in practice and in exam-style troubleshooting: editor presentation, compiler parsing, header availability, and runtime behavior are different layers. Record which layer failed before changing several settings at once.
Study the language features by behavior
The fastest way to retain C17 material is to connect each feature to a code-reading or debugging task. Build short programs, predict the result before compiling, and then explain any difference. The official source confirms the supported feature families but does not provide an exam question bank, so use original exercises rather than memorized answer patterns.
Alignment and compile-time assertions
Practise _Alignas and _Alignof together. Write a structure or object with an explicit alignment requirement, query the alignment, and use _Static_assert to enforce the assumption during compilation. Then change the assumption deliberately and observe the diagnostic. Your notes should distinguish an alignment declaration from a runtime value and a compile-time assertion from a runtime check.
Review the associated interface as part of the exercise. The objective is not merely to recognize a macro name; it is to explain why a declaration needs alignment, how the requirement is expressed, and what evidence shows that the compiler accepted it.
Generic selection and type-directed code
Use _Generic to create a small type-directed dispatch example and include the relevant context in your reading. Trace the controlling expression, the matching association, and the selected function or expression. Then alter the expression's type and predict the result before compiling.
Pay attention to type details that are easy to overlook, including qualifiers, pointer types, and conversions. When reviewing an answer, state the controlling type and the selected association explicitly. That habit is more reliable than choosing an option because the macro resembles an overloaded function.
restrict and aliasing promises
Practise reading restrict-qualified pointers as promises about how an object is accessed through pointer expressions during the relevant execution. Do not reduce restrict to a general speed hint. Write a small function, identify the objects accessed through the restricted pointers, and explain whether the caller satisfies the function's assumptions.
Keep the exercise focused on interpretation and safe reasoning. If the code violates the promise, avoid claiming a particular output unless the standard and compiler behavior establish it. The preparation goal is to recognize the contract and its optimization implications, not to predict an arbitrary result from undefined or invalid usage.
_Noreturn, pragmas, and standard headers
Create a function declared with _Noreturn and include where appropriate, then verify how the compiler treats a call path that is expected not to return. Separately, inspect _Pragma usage and the warning-control example from the official announcement. Explain what the directive does to compiler processing and why warning suppression should remain narrow.
Read the header and keyword forms as related but not interchangeable concepts. The source lists _Noreturn with , _Alignas and _Alignof with , and _Generic with . Your revision notes should identify both the language construct and the header context instead of treating all entries as preprocessor macros.
Feature-test macros and standard identification
Use __STDC_VERSION__ as a direct check of the selected C language version in a controlled program. Under the documented MSVC support, it expands to 201112L for C11 and 201710L for C17. This is a useful verification exercise because it tests the effective language mode rather than the setting you remember selecting.
Also review __STDC_NO_VLA__ and the feature-test behavior around unsupported functionality. The official announcement specifically discusses C11/C17 selection with the __STDC_NO_VLA__ define and explains that some developers prefer this combination. Do not infer from that discussion that variable-length arrays are supported by MSVC; instead, verify the compiler's feature macros and distinguish required support from optional or absent features.
Use a staged roadmap instead of random question practice
A practical roadmap moves from environment verification to language behavior, then to troubleshooting and timed decision-making if the provider confirms a timed assessment. Each stage should produce an artifact you can review: a configuration checklist, a feature notebook, a set of original programs, and a log of mistakes.
Stage one: establish the baseline
Start by listing what you can already explain without documentation: C versus C++, .c versus .cpp, /std:c17, /TC, SDK selection, and the conforming preprocessor. Then install or verify the documented prerequisites. Build one minimal .c file and confirm that the project uses ISO C17 (2018) Standard (/std:c17).
If the baseline fails, postpone advanced feature study. A broken or ambiguous environment makes every later result harder to interpret. Capture the first diagnostic, fix one configuration issue, and rerun the same test.
Stage two: build a feature notebook
Create one page for each supported feature family: alignment, generic selection, compile-time assertions, restrict, non-returning functions, pragmas, and the relevant standard headers. Each page should contain a definition in your own words, a minimal code example, a likely misuse, and the diagnostic or result you expect.
Add a separate boundary page for optional and unavailable areas. Include the absence of complex-number support, the lack of current support for C11 optional features, the C11/C17 __STDC_VERSION__ distinction, and the documented realloc limitation described below. This prevents overgeneralizing from a list of supported features.
Stage three: compare configurations
Use the same source file to compare C11 and C17 settings, then inspect __STDC_VERSION__. The announcement says that, for the supported versions, there are no differences except for that macro value. Next, compile a .c file under the correct C setting and deliberately rename it .cpp or remove /TC; record how the effective language changes.
This exercise teaches a high-value diagnostic sequence: identify the file language, inspect the selected standard, verify the SDK, and only then investigate source-level errors. Repeat the sequence until you can perform it without relying on a remembered screenshot of the property pages.
Stage four: troubleshoot realistic build failures
Prepare cases involving an old SDK, an incorrect file extension, an unset C Language Standard property, missing C++ workload components, and preprocessor incompatibility. For each case, write the smallest corrective action and the evidence that would confirm it worked.
Do not “solve” every failure by selecting the newest setting blindly. The official documentation recommends the latest version available, but a team may need to understand the exact SDK selected by a project. Practise both approaches: selecting the latest installed SDK and selecting a specific installed version when reproducibility requires it.
Stage five: rehearse explanations
For every practice problem, explain why the answer is correct and why the tempting alternatives are wrong. Include the governing setting, feature rule, or implementation boundary. If an assessment uses multiple-choice items, this method is safer than memorizing option positions or short phrases.
Only add timing drills after you obtain verified provider information about the assessment format. The supplied sources do not establish a time limit, question count, delivery method, or scoring model, so no responsible study plan can assign a precise practice pace from these materials.
Avoid these preparation mistakes
Most avoidable errors come from confusing C17 language knowledge with MSVC project configuration. Correct the environment first, verify the active language mode, and treat unsupported or implementation-specific behavior as a boundary to investigate rather than a fact to fill in from memory.
Mistaking C++ compilation for C17 compilation
A .cpp file uses the C++ language standard property by default. Seeing a C-like source file compile does not prove that C17 was selected. Use a .c file or /TC, set the C Language Standard property, and verify the result with a focused test such as __STDC_VERSION__.
Treating every C11 feature as available
The official material says required C11 and C17 features are supported but that C11 optional features are not currently supported. Complex numbers are specifically identified as absent. Avoid study notes that label the entire C11 library or every optional facility as available in this toolchain.
Ignoring SDK and runtime prerequisites
A language switch alone is not a complete installation. The documented support requires Visual Studio 2019 version 16.8 or later, Windows SDK 10.0.20348.0 (version 2104) or later, and an updated Universal C Runtime. Check those dependencies before treating a build failure as a language misunderstanding.
Overtrusting IntelliSense
Editor highlighting is not the same as compilation support. The official announcement limits current IntelliSense highlighting to keywords rather than macros introduced by standard headers. Compile a controlled example and inspect compiler output instead of diagnosing support from colorization.
Assuming C17 changes everything from C11
The supplied MSVC announcement describes C17 as essentially a bug-fix release and reports no differences between the C11 and C17 versions except __STDC_VERSION__. Study the defect-report relationship and version-identification behavior rather than inventing a large new feature list for C17.
Overlooking the realloc boundary
The announcement states that DR 400 support is currently unimplemented for realloc because the change would break ABI. Treat this as a documented implementation limitation, not as a universal statement about all C17 implementations. If a question or code review involves realloc and DR 400, identify the toolchain context before drawing a conclusion.
Using dumps as a substitute for competence
Unverified question dumps can contain obsolete settings, wrong answers, or claims that are unrelated to the published technical evidence. They cannot establish the official blueprint, and memorizing them does not demonstrate that you can configure a project or reason about C17 code. Use original exercises and official documentation for verification.
How to decide whether you are ready
Readiness means you can prove the effective configuration and explain code behavior, not simply recognize C17 terminology. Before scheduling, complete a self-review that separates verified knowledge from assumptions about the exam provider.
Use a configuration check
You should be able to identify the Visual Studio version, confirm the Windows SDK requirement is met, locate the Windows SDK Version property, select ISO C17 (2018) Standard (/std:c17), and explain when /TC is needed. Repeat the setup from a clean project rather than relying on an old project whose inherited properties may hide the real configuration.
Use a code explanation check
Choose one original example for _Generic, one for alignment, one for _Static_assert, and one for restrict. Explain the controlling type, alignment requirement, compile-time condition, or aliasing contract without running the program. Then compile the examples and compare the result with your prediction.
Add a version check using __STDC_VERSION__ and a boundary check involving a feature that is not supported or is subject to a documented limitation. The point is to demonstrate discrimination: supported required feature, optional feature, absent feature, and implementation-specific limitation are different categories.
Use a troubleshooting check
Give yourself a project that contains a .cpp file, an incorrect standard property, and an unavailable SDK selection. Fix the issues in a deliberate order and write down the evidence for each fix. If you change several properties simultaneously, repeat the exercise with one change at a time so that you understand causation rather than merely reaching a successful build.
Verify scheduling information separately
Before making a payment or booking decision, confirm the exam sponsor and official registration page, eligibility or prerequisites, price, delivery method, available languages, score policy, retake rules, question format, duration, and current status. None of those C17 exam details is established by the supplied official sources. The AWS page supplied here is an AWS certification scheduling page, not evidence for C17 requirements, so do not use it to fill the gaps.
What to do next
Begin with a clean C project and a one-page environment record. Once the project compiles as C17, work through the feature notebook and keep a mistake log. After that, validate the provider-specific exam rules independently and adjust the roadmap only where the official exam documentation confirms additional objectives.
A practical first session
Install or verify the required Visual Studio and SDK components, open a C project, set the Windows SDK Version, choose ISO C17 (2018) Standard (/std:c17), and confirm that a .c file is compiled as C. Add a small program that reports __STDC_VERSION__. Save the project settings and the compiler output as your baseline.
Do not start by collecting large sets of purported exam questions. The first session should answer a more useful question: can your machine and project demonstrate the standard mode you intend to study? If not, fix that before interpreting feature diagnostics.
A practical review cycle
After each study session, close the documentation and write a short explanation of one feature, one configuration setting, and one boundary. Reopen the official source only to check the explanation. This active-recall cycle exposes whether you understand why /std:c17, /TC, the SDK, and /Zc:preprocessor matter together.
When your explanation is stable, rebuild the corresponding example from memory. Keep failed attempts in the log; they show which distinctions still need work and provide better revision material than a list of correct answers without reasoning.
A final evidence check
Use the official Microsoft documentation for current installation and configuration information, because the supplied Learn article is identified as last updated on 2021-10-29 and toolchain support can change. Confirm any newer Visual Studio or SDK guidance at the official source before changing a production environment or treating an older setup instruction as current.
Finally, obtain the exam-specific facts from the provider. Schedule only when you know what C17 means in that catalogue, what skills are assessed, and which delivery and scoring rules apply. Keep the technical preparation and the booking decision separate so that an uncertain catalogue label does not become an unsupported exam claim.
Conclusion
The strongest C17 preparation combines standards reasoning with disciplined MSVC verification. Learn the required feature families, practise the difference between C and C++ project settings, confirm the SDK and runtime prerequisites, and test boundaries such as optional features, complex numbers, feature-test macros, and the documented realloc limitation. Because the supplied sources do not publish a C17 exam blueprint or scheduling specification, verify those provider details independently. Your next concrete action is to build a clean .c project in ISO C17 mode, record the effective configuration, and begin a feature-and-troubleshooting log.
Related exams
- B1 exam — Regulatory Environments for Benefits Programs
- C1 exam — Regulatory Environments for Compensation Programs
- CECP exam — Certified Executive Compensation Professional Exam
- C3E exam — Quantitative Principles in Compensation Management
- GR4 exam — Base Pay Administration and Pay for Performance
- GR7 exam — International Remuneration - An Overview of Global Rewards
