Introduction to Data Types and Type Specifiers in C++ Programming

Basics in c++:

• Comments does not paritipate in the execution.
• It clearly explains about the readability ,description of the program.purpose of the program
• The primary purpose of comments is to provide additional context or details about specific lines of code.
• Programmers frequently use comments to document their work and improve code maintainability.

Why Comments are used in C++?               

It makes a program more readable

It gives description of the code.

After a long time u r recap the code means the code means the comments says the program what is supposed to do.

• Types of comments :

Single line(comments) : single line does not pariticipate in the execution. The compiler is to ignore the  that single line after this comment.

#include <iostream>

using namespace std;

int main()

{

                // compiler

                cout << “iies!”;

                return 0;

}

Multiline comments:

Multiple lines of comments:ignores a multi line comments by the compiler

// C++ Program to demonstrate Multi line comment

#include <iostream>

using namespace std;

int main()

{

                /* Multi line comment which

                will be ignored by the compiler

                */

                cout << “Hello iies!”;

                return 0;

}

• Tokens:

Every single element in the c program is said to be an token.

• Keywords
• Identifiers
• Constants
• Strings
• Special Symbols
• Operators

Keywords:

1.Reserved  words

2.Predefined words.

3.we cannot redefine keyword  for  example( int  int 4);

1. Inherited from C:
   • 32 keywords (e.g., int, return, if, while).
2. Added in C++:
   • Additional keywords for object-oriented programming, templates, and advanced features (e.g., class, virtual, template, namespace).
3. Modern Features:
   • Introduced in newer standards for concepts, concurrency, and coroutines (e.g., constexpr, concept, co_await, requires)

Storage Class Specifiers

1. auto:

auto x = 10; // Type deduced as int

• • In earlier C++, it specified automatic storage duration (default for local variables).

2. register:

• • • Suggests that the variable should be stored in a CPU register for faster access (modern compilers often ignore this).

3. static:

• • • Used to define:
      • Variables with static storage duration.
      • Members belong to the class, not an instance.

4. extern:

• • • • Declares a variable or function that is defined in another file or scope.

Type Specifiers

5. char, int, float, double, short, long, signed, unsigned:

• • Specify data types.
  • Example: unsigned int defines a non-negative integer type.

6. void:

• • • Specifies a function that does not return a value.

Control Flow

7. if, else:

• • Conditional statements for decision-making.

8. switch, case, default:

• • • Used for multi-way branching.

switch (x) {

    case 1: /* Code */; break;

    default: /* Code */;

}

9. for, while, do:

• • Looping constructs:
    • for: For a specified number of iterations.
    • while: Iterates as long as a condition is true.
    • do-while: loop runs at least once.

10. break, continue:

• • • • Control loop flow:
        • break: Exit the loop immediately.
        • continue: Skip the current iteration.

11. goto:

• • • • • • Transfers control to a labeled statement (rarely used due to readability concerns).

Object-Oriented Keywords

12. class:

• • used to define user-defined types (blueprints for objects).

class myclass {    public:        int x;};

13. public, private, protected:

1. • access specifiers:
     • public: accessible from anywhere.
     • private: accessible only within the class.
     • protected: accessible within the class and derived classes.

14. virtual:

1. • specifies a function for runtime polymorphism.

15. this:

1. • a pointer to the current object.

16. friend:

1. • grants another class or function access to private/protected members.

17. template:

1. • enables generic programming by defining functions/classes that work with any data type.

 template <typename t>

18. operator:

1. • overloads operators for user-defined types.

19. typedef:

1. • creates an alias for an existing type.

 typedef unsigned int uint;

20. union:

1. • defines a data structure where all members share the same memory space.

Exception handling:

21. try, catch, throw:

• • handle runtime errors (exceptions).

 try {    // code that may throw} catch (exception& e) {    // handle exception

22. return:

• • specifies the return value of a function.

23. inline:

• • suggests the compiler replace function calls with the function’s body to reduce overhead.

24. sizeof:

• • returns the size of a data type or object in bytes.

int x = sizeof(int); // typically 4

25. volatile:

• • indicates a variable can be changed unexpectedly (e.g., hardware registers, multi-threading).

26. const:

• • declares variables whose values cannot be modified after initialization.

27. asm:

• • allows embedding assembly language instructions directly in c++ code (rarely used).

Constants:

Constants  in c  it cannot change the value once it is defined.

// C program to illustrate constant variable definition

#include <stdio.h>

int main()

{

    const int integer_const = 34;

    const char character_const = ‘B’;

    const float float_const = 12.22;

    printf(“Printing value of Integer Constant: %d\n”,

           integer_const);

    printf(“Printing value of Character Constant: %c\n”,

           character_const);

    printf(“Printing value of Float Constant: %f”,

           float_const);

    return 0;

}

Strings in c++:

——————-

// C++ Program to demonstrate strings

#include <iostream>

using namespace std;

int main()

{

    char s[] = “”;

    cout << s << endl;

    return 0;

}

// C++ program to create std::string objects

#include <iostream>

using namespace std;

int main()

{

    string str(“iies”);

    cout << str;

    return 0;

}

#include <iostream>

using namespace std;

int main()

{

    string str(5, ‘g’);

    cout << str;

    return 0;

}

Using C-style strings

// C++ Program to demonstrate C-style string declaration

#include <iostream>

using namespace std;

int main()

{

    char s1[] = { ‘g’, ‘f’, ‘g’, ‘\0’ };

    char s2[4] = { ‘g’, ‘f’, ‘g’, ‘\0’ };

    char s3[4] = “gfg”;

    char s4[] = “gfg”;

    cout << “s1 = ” << s1 << endl;

    cout << “s2 = ” << s2 << endl;

    cout << “s3 = ” << s3 << endl;

    cout << “s4 = ” << s4 << endl;

    return 0;

}

Other Operators:

Semicolon (;): It is used to terminate the statement.

Square brackets []: They are used to store array elements.

Curly Braces {}: They are used to define blocks of code.

Scope resolution (::): Scope resolution operator is used to access members of namespaces, classes, etc.

Dot (.): Dot operator also called member access operator used to access class and struct members.

Assignment operator ‘=’: This operator is used to assign values to variables.

Double-quote (“): It is used to enclose string literals.

Single-quote (‘): It is used to enclose character literals.

Operators:

• Unary operators
• Binary operators
• Ternary operators

.