Introduction to C++ Programming

Introduction to C++ Programming

• The ANSI-C++ standard was accepted as an international standard in November 1997
• C++ language existed long ago (1980s) prior to the ANSI standard
• Many compilers do not support the new capabilities included in ANSI-C++, especially those released prior to the standard's publication

Compilers

• Creating, compiling, and running programs are the stages of computer program development
• An integrated development environment (IDE) typically integrates all these parts into one system
• Compilers are specially tailored to make C++ program creation easier than using basic editors like Notepad
• Compiling and running can be done from the same screen within an IDE

Creating

• Program creation involves designing the program and physically creating it
• Creating the physical program means typing the instructions into a text editor
• C++ file names typically end with ".cpp"
• Compilers often automatically add the correct filename extension
• The filename part after the dot (.) is known as the file extension
• Source code is the information held in the file, which is a plain text file understandable by text editors

Compiling and Running

• To be executed by a computer, programs must be compiled to convert source code into machine instructions, creating an executable file
• Compilation details depend on the computer system and software
• A successfully compiled program results in an executable file, often with a ".exe" extension on IBM-compatible systems

Additional Notes on Executables

• Changing a filename extension from .cpp to .exe does not create a program
• Executable programs can be run by double-clicking, without needing the compiler

Linking

• Linking is a compilation phase that merges necessary components to create a running program
• Linking incorporates information for tasks like displaying messages and reading keyboard input
• Without linking, programmers would need to manually code these functions

Fundamentals of C++ Programming Language

• A C++ program is built from a sequence of characters

Character Set

• Lowercase letters (a – z) are valid characters
• Uppercase letters (A – Z) are valid characters
• Digits (0 – 9) are valid characters
• Special characters (+, /, -, *, =, (,) are valid characters

Variables, Data Types, Constants

• Variables in C++ are data objects manipulated within programs
• Variables are named values that can change during program execution but must be initilized before use

Variable Initialization

• Variables that are not explicitly initialized do not default to zero, but contain a random number
• It is crucial to initialize variables before using them in calculations
• Prior to use, variables must be declared in the declaration list, specifying their data type (char, int, float, etc.)

Variable Names

• Variable names can be up to 31 characters long
• Uppercase and lowercase letters are distinct within variable names
• Using lowercase names is preferable for variables
• The underscore is a valid character, but should not be the first character of a variable name
• Numerical digits are valid, but cannot be the first character of a variable name

Valid and Invalid Variable Names

• temp_data, velocity, unit_1, pay_period, day_month_year, and fred are valid variable names
• 40th_birthday, @discount, %_rate, 2percent, bad-variable, and #fred are not valid variable names

Reserved Keywords

• Keywords, which are reserved for C++ commands, can not be used as variables
• Keywords are case-sensitive and should be lowercase
• Names of data types (int, char, float) can not be used as variables

C++ Keywords

• asm, auto, bool, break, case, catch, char, class, const, const_class, continue, default, delete, do, double, dynamic_const, dynamic_cast, else, enum, explicit, extern, false, float, for, friend, goto, if, inline, int, long, mutable, namespace, new, operator, private, protected, public, register, reinterpret_cast, return, short, signed, sizeof, static, static_cast, struct, switch, template, this, throw, true, try, typedef, typeid, typename, union, unsigned, using, virtual, void, volatile, and wchar_t are C++ keywords.

Meaningful Variable Names

• Use meaningful names to enhance code understanding, describing the variable's purpose
• Simple operations with variables can be expressed in C++

Instruction Set Example

• a = 5; b = 2; a = a + 1; result = a - b;

Declaring Variables

• Declare a variable by specifying its data type and name, followed by a semicolon
• Syntax: data_type variable_name;

Case Sensitivity

• Variables and keywords are case-sensitive
• num and Num are distinct
• float is a keyword that must be lowercase

Data Type Examples

• int value; declares an integer variable
• char letter; declares a character variable, which can only hold one character

Initializing Variables

• Assign an initial value during declaration using the assignment operator (=)
• float sum = 0.0; assigns 0.0 to float variable sum
• Variables can be reassigned new values at any point in the program
• sum = 3.2; alters sum's value from 0.0 to 3.2

Initialization Notes

• Variables must be initialized before being used in expressions
• Float values should be assigned with decimal points (e.g., 0.0 instead of 0)

Code Combination

• Multiple single-line declarations can often be combined
• int value1; int value2; int sum; value1 = 32; value2 = 27; can be written as int value1 = 32; int value2 = 27; int sum;

Identifiers

• Identifiers consist of letters, digits, and underscores
• While the length of an identifier is unlimited, some compilers only consider the first 32 characters
• Spaces and special characters are prohibited in identifiers
• Variable identifiers must start with a letter or underscore, and cannot start with a digit

Rules for Identifiers

• Identifiers cannot match C++ keywords or compiler-specific terms
• Using keywords as identifiers can lead to confusion

ANSI-C++ Standard Keywords

• Keywords include asm, auto, bool, break, case, catch, char, class, const, const_cast, continue, default, delete, do, double, dynamic_cast, else, enum, explicit, extern, false, float, for, friend, goto, if, inline, int, long, mutable, namespace, new, operator, private, protected, public, register, reinterpret_cast, return, short, signed, sizeof, static, static_cast, struct, switch, template, this, throw, true, try, typedef, typeid, typename, union, unsigned, using, virtual, void, volatile, wchar_t

Alternative Representations

• and, and_eq, bitand, bitor, compl, not, not_eq, or, or_eq, xor, xor_eq are alternative representations for some operators and should not be used an identifiers

Compiler-Specific Keywords

• far, huge, and near are keywords in some compilers that generate 16-bit code

Data Types

• Variables are stored in computer memory, requiring the computer to know the data type being stored

Memory Organization

• Memory is organized in bytes, the smallest manageable unit
• A byte can store a small amount of data, like an integer between 0 and 255 or a character
• Complex data types group several bytes to store long numbers or decimals

Fundamental Data Types in C++

• Next are existing fundamental data types in C++, with their ranges:

Char

• Size: 1 byte
• Description: character or integer 8 bits length
• Range: signed: -128 to 127, unsigned: 0 to 255

Short

• Size: 2 bytes
• Description: integer 16 bits length
• Range: signed: -32768 to 32767, unsigned: 0 to 65535

Long

• Size: 4 bytes
• Description: integer 32 bits length
• Range: signed: -2147483648 to 2147483647, unsigned: 0 to 4294967295

Int

• Size: depends on the system
• Description: integer
• MSDOS: 16 bits, 32-bit systems (Windows 9x/2000/NT): 32 bits

Float

• Size: 4 bytes
• Description: floating point number
• Range: 3.4e + / - 38 (7 digits)

Double

• Size: 8 bytes
• Description: double precision floating point number
• Range: 1.7e + / - 308 (15 digits)

Long Double

• Size: 10 bytes
• Description: long double precision floating point number
• Range: 1.2e + / - 4932 (19 digits)

Bool

• Size: 1 byte
• Description: stores boolean value
• Value: true or false

wchar_t

• Size: 2 bytes
• Description: wide character to store international characters

Notes on Data Types

• The bytes and range of values may vary depending on the OS
• Included values are commonly accepted and used
• Pointers and void parameter type specification are additional data types

Declaring Variables

• In C++, variables must be declared specifying their data type
• Syntax: data type specifier (int, short, float...) followed by a valid variable identifier

Declaration Examples

• int a; declares an integer variable a
• float mynumber; declares a float variable mynumber
• Declared variables can be used within their scope in the program

Declaring Multiple Variables

• Multiple variables of the same type can be declared on one line, separated by commas
• int a, b, c; declares three integer variables a, b, and c

Integer Data Types

• Integer data types (char, short, long, int) can be signed/unsigned
• Specify signed/unsigned before the data type to define the range of numbers

Signed vs Unsigned

• signed int MyAccountBalance; and unsigned short NumberOfSons; show the signed/unsigned specification

Default Type

• If signed/unsigned is not specified, the type is assumed to be signed

Equivalent Declarations

• unsigned MyBirthYear; and unsigned int MyBirthYear; are equivalent

Variable Initialization

• Local variables are undetermined by default
• Assign a value upon declaration: type identifier = initial_value;

Variable Initialization example

• float sum = 0.0; assigns initial value