CS201 – CPP Programming Basics: Variables, Data Types, Operators | VU Lecture Notes

• Variables and Constants: Variables store changing data while constants remain fixed during execution.

  int age = 20;
  const float PI = 3.14;

• Basic Data Types (int, float, char, bool): Different data types allow different forms of data representation.

  int marks = 85;
  float temperature = 36.6;
  char grade = 'A';
  bool isPassed = true;

• Literals in C++: Literals are raw values written in code.

  int a = 10;      // Integer literal
  float b = 5.75;  // Floating-point literal
  char c = 'Z';    // Character literal
  bool d = true;   // Boolean literal

• Arithmetic Operators: Used to perform basic math operations.

  int x = 10, y = 3;
  int sum = x + y;
  int product = x * y;
  int mod = x % y;

• Logical Operators: Used in decision making.

  int age = 22;
  bool hasID = true;
  if (age >= 18 && hasID) {
      cout << "Access granted.";
  }

• Comparison Operators: Used to compare two values.

  int a = 5, b = 10;
  if (a != b) {
      cout << "Values are not equal.";
  }

• Assignment Operators: Used to assign values to variables.

  int num = 10;
  num += 5;  // num = num + 5;
  num *= 2;  // num = num * 2;

• Type Conversion in C++: Changing one data type to another.

  int a = 10;
  float b = (float)a / 3;
  cout << b; // Output: 3.33333

• Constants and the const Keyword: Use const to define fixed values.

  const int MAX_USERS = 100;
  cout << "Max users allowed: " << MAX_USERS;

• Scope of Variables: Defines where a variable can be accessed.

  void func() {
      int localVar = 10;  // Local scope
  }
  int globalVar = 20;     // Global scope

• Identifiers and Naming Conventions: Naming should be meaningful and consistent.

  int userAge; // CamelCase
  float average_score; // Snake_case

• Input and Output Using cin and cout: Standard way to get user input and print output.

  int age;
  cout << "Enter your age: ";
  cin >> age;
  cout << "You entered: " << age;

• Single-line and Multi-line Comments: Used to explain and document code.

  // This is a single-line comment
  
  /*
   This is a
   multi-line comment
  */

• Best Practices for Clean Code: Use good formatting, indentation, and meaningful names.

  // Bad
  int a; a=10;cout<

• Common Beginner Mistakes in C++: Avoid uninitialized variables, missing semicolons, and incorrect operator usage.

  // Error: uninitialized variable
  int value;
  cout << value; // May produce garbage value
  
  // Error: Using '=' instead of '=='
  if (value = 10) {  // Should be '=='
      cout << "Value is 10";
  }

Topics Covered

• Variables and Constants: Variables are memory locations used to store data that can be changed during program execution. C++ requires each variable to be declared with a specific data type, such as int for integers or float for decimal values. Constants, on the other hand, are fixed values that cannot be changed after they are defined. The const keyword is used to define constants in C++, ensuring that the value remains the same throughout the program. Understanding how to correctly use variables and constants is crucial for writing dynamic and reliable programs.
• Basic Data Types (int, float, char, bool): C++ provides several fundamental data types for representing different kinds of information. The int data type is used for whole numbers, float and double are used for floating-point numbers (decimals), char is used for single characters (like 'A' or 'z'), and bool represents Boolean values (true or false). Selecting the correct data type is essential for memory optimization and program accuracy. These types form the building blocks of all C++ programs and are widely used in both basic and advanced programming.
• Literals in C++: Literals are the fixed values that appear directly in the code. They include integer literals (e.g., 100), floating-point literals (e.g., 3.14), character literals (e.g., 'a'), and string literals (e.g., "Hello"). C++ also supports Boolean literals (true and false) and hexadecimal or octal number representations. Understanding literals helps in writing clear and concise expressions, especially when assigning values to variables or performing operations.
• Arithmetic Operators: Arithmetic operators are used to perform mathematical calculations. These include + (addition), - (subtraction), * (multiplication), / (division), and % (modulus). Mastery of arithmetic operators allows programmers to create expressions that calculate values, evaluate formulas, or process data. Arithmetic operations are foundational in almost every type of program, from simple calculators to complex data processing applications.
• Logical Operators: Logical operators help in making decisions within a program by evaluating expressions that result in true or false. The three primary logical operators are && (AND), || (OR), and ! (NOT). These operators are mainly used in conditional statements like if and while loops. For example, a condition can check if a user is above 18 AND has a valid ID card. Proper use of logical operators leads to efficient and readable decision-making logic.
• Comparison Operators: Also known as relational operators, these are used to compare two values. They include == (equal to), != (not equal to), > (greater than), < (less than), >= (greater than or equal to), and <= (less than or equal to). These comparisons are crucial in loops and conditional statements, determining whether a particular block of code should execute. Comparison operators are vital in tasks like sorting, filtering, and user input validation.
• Assignment Operators: Assignment operators are used to assign values to variables. The most basic is =, but there are also compound assignment operators such as +=, -=, *=, /=, and %=, which perform the operation and assignment in a single step. For example, x += 5; is equivalent to x = x + 5;. These operators improve code readability and help in performing operations more efficiently.
• Type Conversion in C++: Type conversion involves changing the data type of a value from one type to another. It can be either implicit (automatic) or explicit (manual). Implicit conversion is handled by the compiler when it safely converts one type to another (e.g., int to float). Explicit conversion, also known as casting, is done by the programmer using syntax like (float)intVar. Understanding type conversion is important for preventing errors and ensuring that operations involving multiple data types are carried out correctly.
• Constants and the const Keyword: The const keyword is used in C++ to define a variable whose value cannot be modified after initialization. This is particularly useful for defining fixed values like PI or maximum sizes for arrays. Using constants enhances program stability and makes code easier to maintain. Attempting to modify a const variable results in a compile-time error, which protects against accidental changes.
• Scope of Variables: The scope of a variable refers to the region of the code where the variable can be accessed. Local variables are declared inside functions or blocks and are only available within that block. Global variables are declared outside of all functions and can be accessed throughout the program. Proper management of scope ensures that variables are only accessible where needed, reducing the risk of bugs and making the code cleaner and more efficient.
• Identifiers and Naming Conventions: Identifiers are the names given to variables, functions, arrays, classes, and other user-defined elements. They must follow specific rules: start with a letter (or underscore), can include numbers, and cannot use reserved keywords. Good naming conventions, such as using meaningful names and camelCase or snake_case, enhance readability and maintainability of the code. Proper identifiers also help teams collaborate more effectively on large codebases.
• Input and Output Using cin and cout: C++ uses cin and cout for input and output operations, respectively. cin is used to get user input from the console, while cout is used to display output. For example, cout << "Enter age:"; prompts the user, and cin >> age; reads the input into the variable age. These are essential functions for interacting with users and building interactive applications.
• Single-line and Multi-line Comments: Comments are non-executable statements that help document your code. Single-line comments use //, while multi-line comments are enclosed between /* and */. Comments improve code readability and make it easier for others (or your future self) to understand the logic behind complex sections. Writing helpful comments is a hallmark of good programming practice, especially in collaborative environments.
• Best Practices for Clean Code: Writing clean code involves using meaningful variable names, consistent indentation, avoiding hardcoded values, and properly organizing your logic. Including comments, modularizing code into functions, and adhering to naming conventions are all part of best practices. Clean code is easier to debug, understand, and scale as projects grow in size and complexity.
• Common Beginner Mistakes in C++: New programmers often face errors like using undeclared variables, mismatched data types, forgetting semicolons, or misusing assignment vs comparison operators. Recognizing these common mistakes early helps build confidence and avoid unnecessary frustration. The compiler often gives clues to fix errors, so reading error messages is another skill to develop during the learning process.

10 C++ MCQs for Beginners (CS201/MCS)

1. Which of the following is the correct syntax to output "Hello World" in C++?
   • A. print("Hello World")
   • B. cout << "Hello World";
   • C. Console.WriteLine("Hello World");
   • D. echo "Hello World";
2. Which of these is a valid identifier in C++?
   • A. 123name
   • B. my-variable
   • C. _totalAmount
   • D. int
3. What does the following code print? int a = 10; cout << a * 2;
   • A. 20
   • B. 12
   • C. 102
   • D. Compilation error
4. What is the size of an int on most systems?
   • A. 1 byte
   • B. 2 bytes
   • C. 4 bytes
   • D. 8 bytes
5. Which keyword is used to define constants?
   • A. constant
   • B. #define
   • C. final
   • D. const
6. What symbol is used for single-line comments in C++?
   • A. /* */
   • B. //
   • C. #
   • D. --
7. Which operator is used for modulus?
   • A. /
   • B. *
   • C. %
   • D. ^
8. Which of the following is NOT a data type in C++?
   • A. int
   • B. real
   • C. char
   • D. bool
9. What is the default value of an uninitialized variable in C++?
   • A. 0
   • B. Undefined
   • C. NULL
   • D. false
10. Which of the following is a relational operator?
    • A. &&
    • B. !=
    • C. =
    • D. ++

Answer Key (1–10)

1. B
2. C
3. A
4. C
5. D
6. B
7. C
8. B
9. B
10. B