C++ Object-Oriented Flashcards
Expression
An entity with a value that can possibly change that state of memory
Plus
+expr
Minus
-expr
size of
sizeof (expr)
multiplication
expr * expr
Division
expr / expr
remainder
expr % expr
addition
expr + expr
subtraction
expr - expr
simple assignment
variable = expr
comp. assignment
variable op=expr
Literals
Constant values, such as numbers or strings
int num = 10; // 10 is a literal
Variables
Named memory locations whose values can change during program execution
int x = 5;
Operators
Symbols that represent operations to be performed on operands
Arithmetic operators
*
/
Assignment operator
=
Relational operators
==
!=
<
>
<=
>=
Logical operators
&&
||
!
Parentheses
Used to group expressions and alter the order of operations. Can be used to explicitly define the order of evaluation.
int result = (x + y) * 2;
Function calls
Can be part of expressions if they return values
int sum = add(x, y);
Type conversion
When a value is changed from one data type to another in an expression. C++ may perform type conversion when operands of different types are used together in an expression.
int result = 5 + 3.5; // 5 is implicitly converted to a floating-point number
Expression evaluation
Based on the precedence and associativity of operators.
1. Parentheses
2. Unary operators
3. Multiplicative
4. Additive
5. Relational/equality
6. Logical
7. Assignment
Expression evaluation
Based on the precedence and associativity of operators.
1. Parentheses
2. Unary operators
3. Multiplicative
4. Additive
5. Relational/equality
6. Logical
7. Assignment
Primary expression
Basic unit of expressions. Can represent a value or operation in an expression.
Example:
Literal
“Hello” // string literal
Parenthetical Expression
Allows us to change an expression of lower precedence to a primary expression.
(x + 3) * 5 // add x with 3, multiple result by 5
Identifier
Serves as a name for various identities within the program. It can serve as a name for variables, objects, functions etc.
Object (object-oriented programming)
An instance of a class
Object Name
The identifier can be used to name an object, representing a sped instance of a class with its own set of properties and behaviors
MyClass myObject;
Class (object-oriented programming)
A blueprint for creating objects
Class Name
The identifier can be used to name a class, defining the properties and behaviors of objects of that type.
class my class {
// Class definition
};
Namespace
A declarative region that provides a scope for the identifiers declared within it. Identifiers can be used to name namespaces to organize code and prevent conflict.
namespace MyNamespace {
// Namespace contents
}
Program with Parenthetical Expression
include <iostream></iostream>
using namespace std;
int main ()
{
// Variable declaration
int x = 4;
// Printing the first expression with and without parentheses
cout «_space;“Value with parentheses:” «_space;(x + 3) * 5 «_space;endl;
cout «_space;“Value without parentheses:” «_space;x + 3 * 5 «_space;endl «_space;endl;
// Printing the second expression with and without parentheses
cout «_space;“Value with parentheses:” «_space;12 / ( x + 2) «_space;endl;
cout «_space;“Value without parentheses:” «_space;12 / x + 2;
return 0;
}
Unary Expressions
Unary expressions are operations on a single operand. These operations can be** prefix** or postfix, such as increment (++), decrement (–), unary plus (+), unary minus (-), logical negation (!), and bitwise complement (~)
Multiplicative Expressions
Multiplicative expressions involve multiplication (*), division (/), and modulus (%) operations. These expressions evaluate to the product, quotient, or remainder of two operands
Additive Expressions
Additive expressions involve addition (+) and subtraction (-) operations. These expressions evaluate to the sum or difference of two operands.
Assignment Expressions
Assignment expressions involve assigning a value to a variable. They use the assignment operator (=) to assign the value on the right-hand side to the variable on the left-hand side.
Implicit Type Conversion
AKA automatic type conversion, occurs automatically by the compiler when operands of different data types are used in an expression. Does not require any explicit action from the programmer.
Explicit Type Conversion (Casting)
AKA type casting, is performed explicitly by the programmer using special syntax. This allows the programmer to control the type conversion explicitly when necessary.
static_cast <type> (expression</type>
Operator Precedence
determines the order in which operators are evaluated within an expression. Higher precedence is evaluated before lower precedence.
Associativity
determines the order in which operators of the same precedence are evaluated when they appear consecutively. Operators can be left-associative (left to right) or right-associative (right to left). Addition (+) and subtraction (-) are left-associative, they are evaluated from left to right.
Program with Unary Expressions
/*************
* The program shows the use of plus/minus expressions *
*****************/
#include <iostream>
using namespace std;
int main ()
{
// Declaration and initialization
int x = 4;
int y = −10;
// Applying plus and minus operator on variable x
cout << "Using plus operator on x:" << +x << endl;
cout << "Using minus operator on x:" << -x << endl;
// Applying plus and minus operator on variable y
cout << "Using plus operator on y:" << +y << endl;
cout << "Using minus operator on y:" << -y;
return 0;
}</iostream>
sizeof expression
Finds the size of an expression
sizeof (type)
Finds the size of a type
Multiplication Expression Program
/*************
* Shows effects of multiplicative expressions
*
*****************/
#include <iostream>
using namespace std;
int main ()
{
// Multiplication
cout << "Testing multiplication operator" << endl;
cout << "Value of 3 * 4 = " << 3 * 4 << endl;
cout << "Value of 2.4 * 4.1 = " << 2.4 * 4.1 << endl;
cout << "Value of −3 * 4 = " << −3 * 4 << endl << endl;
// Division
cout << "Testing division operator" << endl;
cout << "Value of 30 / 5 = " << 30 / 5 << endl;
cout << "Value of 4 / 7 = " << 4 / 7 << endl;
// Remainder
cout << "Testing remainder operator" << endl;
cout << "Value of 30 % 5 = " << 30 % 5 << endl;cout << "Value of 30 % 4 = " << 30 % 4 << endl;
cout << "Value of 3 % 7 = " << 3 % 7 << endl;
return 0;
}
Run:
Testing multiplication operator
Value of 3 * 4 = 12
Value of 2.4 * 4.1 = 9.84
Value of -3 * 4 = -12
Testing division operator
Value of 30 / 5 = 6
Value of 4 / 7 = 0
Testing remainder operator
Value of 30 % 5 = 0
Value of 30 % 4 = 2
Value of 3 % 7 = 3</iostream>
Compound Assignment
Shorthand notation in programming languages, including C++, to perform an operation and assignment in a single step.
variable op= expression;
What happens when arithmetic operators are applied to Boolean data types?
Boolean data types are subject to implicit type conversion. True is treated as 1 and false is treated as 0.
True + true = 2
False + false = 0
True * true = 1
False * false = 0
When using binary operators, what happens if the
operands are of different types? What is the type
of the return value?
the compiler typically performs implicit type conversion to make the types compatible for the operation.
The result type is typically the “largest” or “widest” type among the operand types.
What happens when arithmetic operators are applied to character data types?
Characters are treated as their ASCII or UTF-8 integer equivalents.
‘A’ + ‘B’ = value ‘A’ + value ‘B’
‘A’ * ‘B’ = value ‘A’ * value ‘B’
test of data type
tool to test the
type of any expression
typeid (expression).name()
Implicit Conversion Type Hierarchy
int -> unsigned int -> long -> unsigned long -> double -> long double
(lowest to highest)
What happens if we try to store a number
larger than the maximum value or smaller than
the minimum value for a type.
The result is overflow or underflow.
Signed and Unsigned Integers
Two different data types to represent whole numbers in C++.
Signed Integers
Can represent both positive and negative numbers.
int
short
long
long long
Unsigned Integers
Can only represent zero to a maximum positive value based on number of bits allocated for their storage.
Overflow
when the result of an arithmetic operation exceeds the maximum representable value for the data type being used.
Underflow
when the result of an arithmetic operation falls below the minimum representable value for the data type being used. (Not applicable to Unsigned Integers since they can’t represent negative values)
Floating-point Overflow and Underflow
where the result of a calculation exceeds the range of representable values or becomes too close to zero to be accurately represented
Floating-point Overflow
the result of a calculation exceeds the maximum finite value that can be represented by the floating-point data type.
The result may become “infinite” or “infinity”, or NaN (not a number)
Floating-point Underflow
the result of a calculation is too close to zero to be accurately represented by the floating-point data type.
The result may be rounded to zero or represented as a denormalized number.
Statement
a complete instruction that performs a specific action. Define the behavior and flow of execution within the program.
What are Manipulators used for?
modify or control the formatting of data being outputted to the console or other output streams. They allow for customization of aspects such as field width, precision, alignment, and output format.
Name some common output manipulators in C++
std::setw(int n)
std::setprecision(int n)
std::fixed
std::scientific
std::setfill(char c)
std::left and std::right
std::boolalpha
std::hex, std::oct, std::dec
What are input manipulators in C++ used for?
modify or control the formatting of data being inputted from the console or other input streams. They allow for customization of aspects such as skipping whitespace, converting case, and input base.
Name some common input manipulators in C++
std::ws
std::skipws
std::noskipws
std::uppercase
std::nouppercase
std::hex, std::oct, std::dec
How can output manipulators be used in C++?
include <iostream></iostream>
#include <iomanip></iomanip>
int main() {
int x = 123;
std::cout «_space;“Decimal: “ «_space;std::dec «_space;x «_space;std::endl;
std::cout «_space;“Hexadecimal: “ «_space;std::hex «_space;x «_space;std::endl;
std::cout «_space;“Octal: “ «_space;std::oct «_space;x «_space;std::endl;
return 0;
}
Output:
Decimal: 123
Hexadecimal: 7b
Octal: 173
What are some examples of no-argument manipulators for output streams?
endl
noboolalpha, boolalpha
dec, oct, hex
noshowbase, showbase
fixed, scientific
noshowpoint, showpoint
noshowpos, showpos
nouppercase, uppercase
left, right, internal
What manipulators are used to output integers in different bases?
dec (base 10)
oct (base 8)
hex (base 16)
What manipulators control whether the base of the number is shown as a prefix?
noshowbase: Does not show the base of the number (default).
showbase: Shows the base of the number with a prefix (0 for octal, 0x for hexadecimal).
What is the purpose of the boolalpha manipulator?
It is used to output boolean values as “true” or “false” instead of 1 or 0, respectively.
Declaration Statement
used to declare a variable or a function, specifying its type and optionally initializing it with a value. A modifier
(called extern) can be added to postpone the definition to some
other part of the program.
Needs a semicolon (;)
Single Declaration Statement
declares a single variable of a specific type.
Example:
short test;
int sum;
double average;
Multiple Declaration Statement
declares multiple variables of the same type in a single line.
Example:
int first, second, third;
double average, mean;
char ch;
Initialization
assigns an initial value to a variable at the time of declaration.
Example:
int first = 0;
double average = 0.0, mean = 0.0;
char ch = ‘a’;
Constant Declaration Statement
declares a named constant with a specific value that cannot be changed during program execution.
Example:
const int FOOT_TO_INCH = 12;
const double TAX_RATE = 8.5;
const double PI = 3.1415926536;
Expression Statement
consists of expression followed by semicolon (;). When program encounters expression statement, it evaluates expression then discards result (if any), treating statement as standalone operation
Example:
num *= 10;
Null Statement
a semicolon (;) by itself, with no other code or operation. It represents an empty or “do nothing” statement
Compound Statement
AKA a block, is a sequence of statements enclosed within a pair of curly braces {}. Allows multiple statements to be grouped together and treated as a single statement.
Example:
{
int x = 10;
cout «_space;“Value of x: “ «_space;x «_space;endl;
}
Return Statement
used to terminate execution of function and return a value to caller of function. Used in non-void return type functions, expected to produce a result.
Less
expr < expr
Less or equal
expr <= expr
Greater
>
Greater or equal
expr >= expr
Equal
expr == expr
Not equal
expr != expr
Pitfall
Avoid using either of the equality operators with floating-point values (precision of value in memory storage unknown)
One-Way Selection
if (Condition)
{
Statement(s)
}
Printing Absolute Value
/*************
* Using if-statement to print the absolute value of a number *
*****************/
#include <iostream>
using namespace std;
int main ()
{
// Declaration
int number;
// Getting input
cout << "Enter an integer:";
cin >> number;
// Finding the absolute value
if (number < 0)
{
number = −number;
}
// Printing the absolute value
cout << "Absolute value of the number you entered is:" << number;</iostream>
return 0;
}
Run:
Enter an integer: 25
Absolute value of the number you entered is: 25
Run:
Enter an integer: −17
Absolute value of the number you entered is: 17
Gross Payment of an Employee
/*************
* Use of if-statement to find gross payment of an employee *
*****************/
#include <iostream>
#include <iomanip>;
using namespace std;
int main ()
{
// Declaration;
double hours;
double rate;
double regularPay;
double overPay;
double totalPay;
// Input
cout << "Enter hours worked:";
cin >> hours;
cout << "Enter pay rate:";
cin >> rate;</iomanip></iostream>
// Calculation that does not depend on decision
regularPay = hours * rate;
overPay = 0.0;
// Calculation that is skipped if hours worked is not more than 40
if (hours > 40.0)
{
overPay = (hours − 40.0) * rate * 0.30;
} // End if
// Rest of the calculation
totalPay = regularPay + overPay;
// Printing output
cout «_space;fixed «_space;showpoint;
cout «_space;“Regular pay = “ «_space;setprecision (2) «_space;regularPay «_space;endl;
cout «_space;“Over time pay = “ «_space;setprecision (2) «_space;overPay «_space;endl;
cout «_space;“Total pay = “ «_space;setprecision (2) «_space;totalPay «_space;endl;
return 0;
}
Run:
Enter hours worked: 30
Enter pay rate: 22.00
Regular pay = 660.00
Over time pay = 0.00
Total pay = 660.00
Run:
Enter hours worked: 45
Enter pay rate: 25.00
Regular pay = 1125.00
Over time pay = 37.50
Total pay = 1162.50
Pitfalls: Assignment versus Equality
if (x = 0) // This statement is always false
{
statement; // The statement is never executed
}
Pitfalls: Forgetting Braces
if (x == 0)
statement1; // Statement1 is executed if x is 0
statement2; // Statement2 is always executed
Pitfalls: Extra Semicolon
if (x == 0); // Semicolon makes the body of if-statement empty
{
statement1; // Statement1 is always executed
statement2; // Statement2 is always executed
}
Two Way Selection
if (boolean-expression)
{
statement1;
}
else
{
statement2;
}
Nested if-else Statement
if(expr1)
{
if(expr2)
{
statement1;
}
else
{
statement2;
}
}
else
if(expr3)
{
statement3;
}
else
{
statement4;
}
}
Dangling else Problem
An else is always paired with the most recent unpaired if
Avoid this issue by using block delimiters
Multi-way Selection
// Compact
if (condition 1)
statement 1;
else if (condition 2)
statement 2;
else if (condition 3)
statement 3;
else if (condition 4)
statement 4;
else
statement 5;
logical not
! expr
logical or
expr || expr
logical and
expr && expr
NOT expression
The NOT operator flips the value of a logical expression
Check for Leap Year
leapYear = (divisibleBy400) || (divisibleBy4 && !(divisibleBy100))
To check for a leap year, we need to check three conditions. If a year is
divisible by 400, it is definitely a leap year.
Otherwise, if the year is divisible by 4, but not by 100, it is also a leap year.
Removing NOT Operator
!(x < 7) -> (x >= 7)
!(x > 7) -> (x <= 7)
!(x == 7) -> (x !
= 7)
!(x && y) -> (!x || !y)
side effects
the observable changes or interactions that occur beyond the direct output or return value of a function or expression. These changes can affect the state of the program, such as modifying variables, altering data structures, or performing input/output operations
short-circuit behavior (software)
When evaluating logical expressions involving && (logical AND) or || (logical OR), the language sometimes doesn’t need to evaluate the entire expression to determine its truth value. Instead, it stops evaluating the expression as soon as it can deduce the outcome.
Example:
In the expression (3 < 2) && (x = 2), the first condition (3 < 2) is false, so the whole expression is false. Since the first condition is false, the second condition (x = 2) doesn’t even need to be evaluated. So, x remains unchanged.
switch statement (multi-way decision)
the decision is based on specific values
break; statements
termination of execution after switch statements
default case
a fallback option in case none of the preceding case conditions match the value being evaluated. It provides a block of code to execute when none of the other case conditions are met.
e.g. a user doesn’t make a choice between A or B so the program must output a “default” choice C.
Combine Cases
If the task performed by several cases is the same, we
can combine the cases.
int main ()
{
// Declaration
char grade;
// Input
cout «_space;“Enter a grade (A, B, C, D, F): “;
cin»_space; grade;
// Decision section using switch statement
switch (grade)
{
case ‘A’:
case ‘B’:
case ‘C’: cout «_space;“Grade is pass”;
break;
conditional expression (decision making)
Only ternary expression in C++
condition ? expression1 : expression2
