Data Types

Every value in C++ has a type that decides how much memory it uses, what range of values it can hold, and which operations make sense. In this lesson you'll meet the full set of fundamental types, learn how big each one is, and avoid the classic traps of overflow and floating-point rounding.

Learn Data Types in our free C++ course — a beginner-friendly interactive lesson with worked examples, a practice exercise and a quick recall.

Part of the free C++ course at LearnCodingFast — hands-on lessons with examples you run in your browser, plus practice exercises and a quick quiz.

Think of types as differently sized buckets . A char is a thimble (1 byte) that holds a single drop. An int is a coffee mug (4 bytes). A long long is a bucket (8 bytes) that holds far more. A double is also a bucket but it's built to hold decimals precisely. Pour too much into a bucket and it doesn't just spill on the floor — it wraps around to the bottom , which is exactly what integer overflow does. Choosing the right-sized bucket up front prevents nasty surprises.

The C++ standard only guarantees minimum sizes; these are the common sizes on a 64-bit desktop. Use sizeof to check on your own machine.

1. The Fundamental Types in Action

Let's declare one of each and print it. Notice char uses single quotes, bool prints as 1 or 0 , and the f suffix on a float literal and the LL suffix on a long long literal pin the value to that exact type.

2. Measuring Size & Range

sizeof tells you how many bytes a type occupies, and the and headers expose each type's minimum and maximum value. Knowing the range matters because a value that exceeds it doesn't error — it silently wraps.

3. Overflow: When a Bucket Runs Out

Add 1 to the largest possible int and it wraps around to the most negative value. For signed integers this is actually undefined behavior — the compiler is free to do anything — so never rely on it. For unsigned integers the wrap is well-defined and predictable.

4. The Floating-Point Trap

Decimals like 0.1 can't be stored exactly in binary, so arithmetic introduces tiny rounding errors. cout hides them by rounding to 6 digits, but they're really there. The rule: never compare two doubles with == . Instead check that their difference is smaller than a tiny tolerance (an "epsilon").

5. auto & Literal Suffixes

auto lets the compiler deduce a variable's type from its initializer — with zero runtime cost. The type it picks depends on the literal: 10 is an int , 2.5 is a double , and suffixes like LL , u , and f nudge it toward a specific type.

Now you try. Fill in the blanks below with the right type or value:

These lines compute a percentage and print it, but they're scrambled. Put them in the correct order so the program compiles and prints Pass rate: 75% .

Why: the must come before main . Inside main , the two int variables are declared first, then percent uses them — and the 100.0 forces double division so we get 75 , not integer-truncated 0 . The print and return 0; come last, and the closing brace ends the function.

Predict the output before revealing each answer.

3 3.5 — 7 / 2 is integer division (remainder dropped), but 7.0 / 2 is double division.

2 — a bool promotes to int in arithmetic, so true + true is 1 + 1 .

4294967295 — unsigned subtraction wraps around to the maximum value rather than going negative.

Pick the right type for each value, and remember to force double division when converting bytes to megabytes. Run it and match the expected output in the comments.

Practice quiz

• Browse all free courses
• Cheat sheets & quizzes
• Coding dictionary