C++ Variables and Fundamental Types

A type tells the compiler how a value is represented and which operations make sense. int is a common signed integer type, double represents floating-point values, bool represents true or false, and char stores a character-sized code unit. std::string is a standard-library type for owned text.

Choose a type from domain meaning. A count should not quietly accept fractional values. Currency calculations should not assume binary floating point is exact. The type is part of the program's contract, not only a storage-size decision.

Initialization gives an object its first value; assignment replaces a value later. Prefer declaring a variable where its first meaningful value is known. int attempts{0}; is safer and clearer than declaring attempts early and hoping every control-flow path assigns it.

Brace initialization also catches narrowing. int whole{3.8}; is rejected instead of silently discarding the fraction. This does not prevent every conversion problem, but it makes object creation more deliberate.

#include <iostream>

int main()
{
  int completed{4};
  double target_hours{7.5};
  bool on_schedule{completed >= 4};

  std::cout << completed << " tasks, "
            << target_hours << " hours, on schedule: "
            << std::boolalpha << on_schedule << '\n';
}

Mark a variable const when it should not change after initialization. The compiler will reject later assignment, preventing accidental edits and helping readers distinguish fixed inputs from evolving state. Configuration loaded at runtime can still be const after loading; const does not mean compile-time-only.

Use meaningful names rather than unexplained literals. const int minutes_per_hour{60}; communicates the rule once. Do not turn every temporary into a global constant; keep names in the narrowest useful scope.

auto total = quantity * unit_price_cents; asks the compiler to infer the type from the initializer. It is valuable when the type is obvious or verbose, especially with iterators. It is harmful when the inferred type hides an important unit, signedness, reference, or conversion.

Inference does not remove types. auto value = 3; is an int, so assigning 3.5 later converts to int rather than changing the variable's type. Inspect the initializer and use an explicit type when it better states the contract.