C/Cpp Pre-test
Operations involving integer types are more efficient than operations with float types.
Are operations involving integer types more efficient than floating types?
1: floor(3.9*a - 0.6) - b 2: (39*a - 6)/10 - b
Assuming a & b are both integer types and a is non-negative, which operation is more efficient? (Sec.2,Note 2.7)
bool can be implicitly converted to int. true = 1, and false = 0
Can bool variable be converted to int?
numeric and pointer values can be implicitly converted to bool: zero value is converted to false and any non-zero is true.
Can numeric values be converted to bool? (Sec.3, note 3.1)
No
Can you take the address of a register?
C: int type Cpp: char type
Data type of character literal
in C, const is no different than any other variable except it cannot be changed at run-time. in Cpp, const variable is a true constant and can be used whenever a constant expression is needed (i.e an array dimension) in C, a const external variable has external linkage while Cpp has internal linkage
Differences in const between C & Cpp
No, register declarations with optimizing compilers might actually lead to inefficient programs - register variables should not be used in general application programs
Do Register declarations always lead to more efficient programs?
This is considered an ill-formed expression as x is modified twice. (x is increased then x is assigned x). value is undefined.
For int x = 1; predict the value in x after: x = ++x;
octal: begins with 0 hex: begins with 0x
How to write octal & hexadecimal numbers?
Implementation defined
If value of character literal containing more than one character, or containing a character or escape sequence not represented in the basic execution char set or representing a value not within the range of unsigned char - how is its value defined?
Whether char means signed or unsigned is implementation dependent
Is char, unsigned or signed?
for shorts, omitting unsigned means signed
Is short signed or unsigned?
For some Cpp objects, in some situations, post-incrementing/decrementing can require significantly more resources than pre-incrementing/decrementing
Is there a difference in computation resources when post-incrementing/decrementing vs pre-incrementing/decrementing?
No, only trailing parameters can be omitted. either default char value is last parameter or int needs default value
Is this function prototype legal: void PringChar(char var = 'X', int number)
int is the most machine efficient type
Most efficient data type?
Prints "4" to stdout. Formatting is irrelevant to the compiler, each else belongs to the previous "if" since the first "if" is false, everything else is skipped and "putchar('4')" is executed
Predict output: if (5 < 4) if (6 > 5) putchar('1'); else if (4 > 3) putchar('2'); else putchar('3'); putchar('4');
Would print "World" as expression is false
Predict the output: cout<<(12<5?"Hello":"World"
Value of x is 4 (sizeof(int)). Commas just define left->right evaluation and x takes the value of the expression that is evaluated last
Predict value of x after: int x = (4,printf("hello"),sqrt(64.),sizeof(int));
A false EOF might be detected or real EOF might be missed. ch should be an int to use the (... != EOF) implementation. would need to use the eof() function to get this implementation to work properly
Predict what will happen: char ch; while ( (ch = cin.get()) != EOF ) cout.put(ch); (note 4.3)
No, because two quotients are possible and which occurs is implementation-defined
Should portable programs do integer division with one or both operands negative? (Sec.2, Note 2.8)
Can use #define but const int is preferred. preferred because, const values have limited scope (macros have "remaining file" scope) debugger can inspect const values, can take address of const variable, no parentheses are needed around initialization
Should you use #define in Cpp?
Good practice says: no. The function assumes constant input, has no way to stop buffer overflow
Should you use gets()?
At minimum, char (signed or unsigned) is represented by 8-bits
Size of a char?
at minimum short is represented using 16 bits
Size of short?
65 if the ASCII character set is used
The value of sizeof('A') is:
implementation dependent: either -5/4==-1 and -5%4==-1 or -5/4==-2 and -5%4==3
The values of -5/4 and -5%4 are, respectively:
variables declared within a block without keywords static or extern; also, formal parameters
What are Automatic Variables?
Automatic variables whose declarations are preceded by the word register - kept in internal machine registers rather than main storage, means much faster access
What are register variables?
char, short, int, long, long long
What are the Integer Arithmetic Data Types?
float, double, long double
What are the floating arithmetic data types?
C: expressions produce type int (0/1) Cpp: expressions produce type bool (true/false)
What data type are the values produced by Relational/Equality expressions in C/Cpp?
The operators && and || guarantee that the operand evaluation will stop as soon as the expressions value (true/false) is known.
What is "Short Circuiting"? (Sec.3 Note 3.2)
Accessing a volatile object, modifying an object, modifying a file, or calling a function that does any of those operations are all "side effects", which are changes in the state of the execution environment. - - basically anything that changes a variable, file. ex: int y; y--;)
What is "Side Effects"?
C: <stdio.h> cpp: <iostream> Returns int when it attempts to read and there is nothing left to read. Has implementation-defined negative value.
What is EOF and where is it defined?
An object that is modified twice between sequence points. This leads to undefined behavior
What is an ill-formed expression?
returns an int (1)
What is the data type returned by this expression: '\25'<100.25F?
Remainder of division: a%b = a-(a/b)*b
What is the modulo definition?
Private members of a class are being accessed by other than a member/friend function.
What is wrong? struct Svalues {char x; int y;} s1 = { 25, 30 }; class Cvalues {char x; int y;} c1 = { 25, 30 };
Only scalar types
What types can be declared Register?
Use these functions for systems where sizeof(char)==sizeof(int), as EOF would be indistinguishable from a legal character. Should also use these functions when input functions (like fgets() fread()) do not return a special value to indicate EOF.
When to use foef() or eof() functions?
C: <limits.h> Cpp: <climits>
Where are Integer arithmetic implementation-specific characteristics found?
C: <float.h> Cpp: <cfloat>
Where are implementation specific characteristics of floating arithmetic data types found?
in the parameter list of the prototype. Can also use function signature, but prototype is better style/recommended
Where is it best to define default values in for functions?
Allows calling function to modify a variable not within its scope. Its also more efficient if its a large object
Why would you want to return a pointer rather than what it points to?
Compound Assignment Operator
combines assignment with some other operation. aka +=, *= etc
String Literal
double quote enclosed sequence. Treated as tokens by the compiler
All sub-integers are converted to type int or unsigned All type float are converted to double All other types are unaltered.
if a function is called before its formal parameter types have been declared (via function def or prototype), all arguments will be converted according to:
EOF cannot be a char as EOF cannot be a member of the 256 legal character set, would cause for lost or false EOF return
is EOF a char?
cannot change value of i, code will not compile because of unassigned constant variable and because code is attempting to change a read-only variable
predict output: const int i; for(i=0;i<5;++i){ cout<<i<<""; }
Will print out: "1 2" due to "short circuiting" - && expression is true so it automatically stops operator evaluation (doesnt get to "or" operand)
predict the output: printf("1") && printf("2") || printf("3")
Character Literal
single quote enclosed sequence. if character is in the basic execution character set, it has that value. aka 'A' = 65 base 10
doubles are commonly represented using 64 bits, with typical precision of 15 digits.
size of double & its precision?
Floats are commonly represented using 32 bits, with a typical precision of 7 digits
size of float & its precision?
at minimum, 16 bits
size of int?
long doubles are commonly represented using 64 or 80 bits. typical 80 bit precision is 19 digits
size of long double & its precision?
at minimum, 64 bits
size of long long?
at minimum, 32 bits
size of long?
C: <stddef.h> Cpp: <cstddef>
where is size_t defined?
increment and decrement operators
y = ++x assigns y = x+1 y = x++ assigns y = x, then increments x = x+1