# Lecture 2: Choose types from meaning, range, and precision ## Give every stored value a deliberate meaning **Instructor:** [Dr. Debasish Pattanayak](https://drdebmath.github.io)

## Range and precision guide type choice. · Choose types for a sensor packet A weather station mixes counts, precise measurements, status flags, and identifiers—each deserves an intentional type. ~~~cpp #include <iostream> int main() { int stationId = 2048; int samples = 86400; double temperature = 31.625; float humidity = 68.4f; bool batteryLow = false; char quality = 'A'; std::cout << std::boolalpha // print bools as true/false << stationId << " " << samples << " " << temperature << " " << humidity << " " << quality << " " << batteryLow << '\n'; } ~~~ **Takeaways** - Range and precision guide type choice. - A type documents intent. - Narrow types are useful only when their limits are understood.

## Static typing checks a variable’s kind before the program runs A **variable** is a named storage location. **Static typing** means types are checked before execution. ~~~cpp int attempts = 0; double temperature = 31.5; char grade = 'A'; bool submitted = false; ~~~ The initializer supplies the first value.

## Choose the fundamental type from the value’s meaning | Requirement | Suitable type | Example | |---|---|---| | whole-number count | <code>int</code> | students | | fractional measurement | <code>double</code> | voltage | | the same in half the storage | <code>float</code> | humidity | | one character | <code>char</code> | grade | | true/false state | <code>bool</code> | connected | <code>double</code> is the default for fractional values; <code>float</code> halves the storage and the precision, and its literals carry an <code>f</code> suffix (<code>68.4f</code>). Sizes are implementation-dependent: inspect them with <code>sizeof</code>, and inspect the ranges with `std::numeric_limits<T>::min()` and <code>::max()</code> from `<limits>`.

## The compiler rejects a mislabeled value before it runs <figure class="course-meme-figure"> <img src="assets/lecture-memes/l02/static-typing.png" alt="A friendly compiler clerk checks labeled bins for a count, temperature, grade, and yes-or-no flag before a small program starts — visual point: No value gets past the clerk without the label it actually deserves." width="900" height="506" loading="lazy"> <figcaption> <p class="course-meme-setup"><strong>Setup</strong> Four values arrive at the checkpoint wearing the wrong labels.</p> <p class="course-meme-punchline"><strong>Punchline</strong> No value gets past the clerk without the label it actually deserves.</p> </figcaption> </figure>

## Signedness and width determine the numeric range <code>signed</code> supports negative and positive values. <code>unsigned</code> represents only non-negative values. Unsigned arithmetic is modular, so it wraps at both ends: <code>0u - 1</code> is not <code>-1</code> but the largest representable value. <code>short</code>, <code>long</code>, and <code>long long</code> change minimum range requirements. Use a modifier only when its range and interaction with other types are understood.

## const prevents accidental reassignment ~~~cpp const double safeLimit = 12.5; double reading = 11.8; // safeLimit = 13.0; // compile-time error ~~~ <code>const</code> prevents modification through that name after initialization.

## Four objects, four boxes — habit picks the wrong one <figure class="course-meme-figure"> <img src="assets/lecture-memes/l02/meaningful-types.png" alt="A student sorts a whole-number counter, a measurement, a single character tile, and a yes-or-no switch into matching containers — visual point: The meaning chooses the container; the habit just grabs the nearest one." width="900" height="506" loading="lazy"> <figcaption> <p class="course-meme-setup"><strong>Setup</strong> Same-looking storage boxes, four very different meanings.</p> <p class="course-meme-punchline"><strong>Punchline</strong> The meaning chooses the container; the habit just grabs the nearest one.</p> </figcaption> </figure>

## Game evolution: Named state gives the world memory | Today's concept | Exact game part enabled | |---|---| | typed variables and constants | remember one actor's row, column, score, and board bounds | ~~~cpp #include <iostream> int main() { const int rows = 5, columns = 9; int headRow = 2, headColumn = 3; int score = 0; bool dirtHere = true; std::cout << std::boolalpha // print bools as true/false << rows << ' ' << columns << ' ' << headRow << ' ' << headColumn << ' ' << score << ' ' << dirtHere << '\n'; } ~~~ **Model check:** row and column are independent whole-number coordinates; dirt is a yes/no fact. **Next unlock · L03:** compute a new coordinate from the current state and one movement delta.

## auto deduces one real type without removing type meaning ~~~cpp auto samples = 12; // int auto mean = 7.25; // double const auto room = 103; // const int ~~~ Use <code>auto</code> when the initializer makes the type obvious.

## Explicit casts make possible information loss visible ~~~cpp double mean = 97.56; int whole = static_cast<int>(mean); // 97 ~~~ An explicit conversion documents intent. Check the destination range first: fractional information may be truncated, and an out-of-range conversion may be invalid.

## "It is a number" is not a finished type decision <figure class="course-meme-figure"> <img src="assets/lecture-memes/l02/range-precision.png" alt="A tiny number container overflows when asked to hold a huge range and spills a delicate fractional measurement beside it — visual point: One dimension says what fits; the other says what detail survives." width="900" height="506" loading="lazy"> <figcaption> <p class="course-meme-setup"><strong>Setup</strong> A tiny container is asked to hold an enormous range and a delicate fraction at once.</p> <p class="course-meme-punchline"><strong>Punchline</strong> One dimension says what fits; the other says what detail survives.</p> </figcaption> </figure>

## Type choice follows meaning, range, and precision - A type describes values and permitted operations. - Choose representation from meaning, range, and precision. - Do not assume exact byte sizes. - Use <code>const</code> for values that must not change. - Make potentially lossy conversions explicit.

## Verify Choose types for a sensor packet with a claim, trace, boundary, and improvement Use the practical example as a small experiment. Before you leave, make the reasoning visible: - **Claim:** Range and precision guide type choice. - **Trace:** name the state that changes and the observation that would confirm it. - **Boundary:** choose one smallest, largest, empty, or invalid input that could expose a defect. - **Improvement:** explain one change that would make the solution clearer or safer. ### Exit ticket Choose one problem to solve now and two to attempt in the lab: - Choose types for roll number, CGPA, hostel block, and fee-paid status. - Print the size and numeric limits of the fundamental arithmetic types. - Demonstrate truncation when a double is converted to int.

## Explain Choose types for a sensor packet without opening the code Explain today’s idea to a partner without opening the code: 1. State the input, output, and one rule the solution must preserve. 2. Point to the operation that makes progress or changes the state. 3. Name the first test you would run after changing the implementation. If the explanation needs “and then another unrelated thing,” split the design before you code.

## Solve five problems to transfer Choose types for a sensor packet **IC151 lab practice · 5 problems** 1. Choose types for roll number, CGPA, hostel block, and fee-paid status. 1. Print the size and numeric limits of the fundamental arithmetic types. 1. Demonstrate truncation when a double is converted to int. 1. Compare signed and unsigned behavior near zero. 1. Use const and auto to model the radius and area of a circle. Reaching this set marks the lecture as studied in this browser. [Open the IC151 lab setup and batch schedule](ic151.html).

## Did you know? - A byte is 8 bits and holds 256 values. The word was coined at IBM in 1956 and deliberately misspelled so it would not be confused with "bit". - ASCII stands for American Standard Code for Information Interchange. `A` is 65 and `a` is 97, so changing case is a difference of exactly 32. - Because a `bool` is stored in a whole byte, eight of them take eight bytes, not one.

## Store position, dirt, battery, and sensor readings without confusing their meanings. **Studio thread:** Encode the cleaning world | Ask | Today’s answer | |---|---| | **Problem** | Store position, dirt, battery, and sensor readings without confusing their meanings. | | **Model** | A robot has discrete state plus approximate physical measurements. | | **Represent** | int for counts/coordinates, bool for facts, double for measurements, const for limits. | | **Solve** | Choose each type from meaning, range, precision, and permitted operations. | | **Verify** | Try zero, the largest expected value, a fractional value, and a lossy conversion. | | **Improve** | Replace magic values with named constants and document units. | **Technique lens:** representation before algorithm **Compare:** one overloaded numeric type versus several meaning-specific types