Ccac C++ 001 - 010 Misc.

Front 1

- also called the heap
- memory reserved for dynamic variables

Back 1

freestore

Front 2

- eliminates a dynamic variable pointed to by a pointer
- returns memory to the freestore
- after delete, the value of pointer is undefined

Back 2

delete

Front 3

- delete [] a;

Back 3

delete dynamic array

Front 4

- creates copy of object
- has one parameter of the same type as the class
- that parameter must be call-by-reference, normally const

Back 4

copy constructor

Front 5

- create a copy of what each member variable is pointing to
- normally used when overloading = or defining copy constructor

Back 5

deep copy

Front 6

- the copy constructor or overloaded = simply copies the member variables from one object to another
- this is the default for compiler created = and copy constructor
- works fine if no pointers or dynamic data

Back 6

shallow copy

Front 7

- copy constructor, the = assignment operator, and the destructor
- if you need any, you need all three
- if missing, compiler will create, but it may not be how you want it

Back 7

big three

Front 8

- variable shared by all objects of the class
- allow some of the advantages of global variables without all the troubles
- can be private so that only objects of the class can directly access it

Back 8

static members

Front 9

- allow some of the advantages of global functions without all the troubles
- does not access the data of any object
- is still a member of a class
- cannot use anything that depends on a calling object
- cannot use any nonstatic variables or nonstatic member functions, unless the nonstatic variable or

function has a calling object that is a local variable or some object otherwise created in the

definition.
- commonly invoked as Class::staticFunction()

Back 9

static functions

Front 10

- declared like this: vector<type> v;
- is a template class
- cannot initialize the ith element using v[i] - you can only change an element that has already been

given a value
- to add an element to a vector for the first time, use the member function push_back
- v.size() returns the number of elements in a vector
- vector<int> v(10); constructor that initializes vector to the number of positions given by the

argument - the first ten elements are initialized to zero

Back 10

vectors

Front 11

- member function of a vector
- adds an element in the next available position
vector<double> sample;
sample.push_back(0.0);
sample.push_back(1.1);
sample.push_back(2.2);

Back 11

push_back

Front 12

- the complete definition of a member function is given in its class
- typically used for very short functions
- the code for the function is inserted at each location where the function is invoked
- go against the principle of encapsulation
- for long functions, the inline version can actually be less efficient
- use the keyword inline before declaration and definition

Back 12

inline functions

Front 13

- nonmember functions that have the privs of member functions
- not a member function of the class, but has access to private members
- name it as a friend function in the class definition
- use the keyword friend
- most commonly are overloaded operators
- can be a friend of more than one class
- provides automatic type conversion

Back 13

friend functions

Front 14

- If the class F is a friend of the class C, then every member function of the class F is a friend of

the class C.
- it is typical for the classes to reference each other

Back 14

friend classes

Front 15

- at least one parameter must be of a class type
- most operators can be overloaded as a member of the class, a friend of the class, or a nonmember,

nonfriend
- the following operators can only be overloaded as (nonstatic) members of the class: =, [], ->, and

()
- you cannot create a new operator
- you cannot change the number of arguments that an operator takes
- you cannot change the precedence of an operator
- the following operators cannot be overloaded: dot. scope:: sizeof question? the .*
- cannot have default arguments

Back 15

rules on overloading operators

Front 16

- automatic type conversion of all arguments
- fullAmount = 25 + baseAmount // legal

Back 16

nonmember nonfriend operator overloading

Front 17

- gives you the efficiency of bypassing accessor and mutator functions and directly accessing member

variables
- when you overload a binary operator as a member operator, the two arguments are no longer

symmetric. one is a calling object, and only the second "argument" is a true argument. this is not

only unaesthetic but also has a very practical shortcoming. any automatic type conversion will only

apply to the second argument.
- fullAmount = 25 + baseAmount; // illegal

Back 17

member operator overloading

Front 18

- best of both worlds (nonmember nonfriend operator overloading & member operator overloading)
- automatic type conversion of all arguments
- gives you the efficiency of bypassing accessor and mutator functions and directly accessing member

variables

Back 18

friend operator overloading

Front 19

- if your class definition contains the appropriate constructors, the system will perform certain

type conversions automatically.
- ex. fullAmount = baseAmount + 25;

Back 19

automatic type conversion via constructors

Front 20

- ends a switch statement

Back 20

break

Front 21

- merely ends one loop iteration

Back 21

continue

Front 22

- a type whose values are defined by a list of constants of type int
- handy for defining a list of identifiers

Back 22

enum

Front 23

- used like a void function that takes one call-by-value parameter of type bool
- #include <cassert>
- an assertion is either true or false
- a macro is very similar to an inline function
- if the precondition is not satisfied, your program will end and an error message will be output
- assert();
- you can turn assert off with #define NDEBUG

Back 23

assert macro

Front 24

- Driver: a special program to do testing
- Stub: simplified version of a missing or untested function

Back 24

stubs and drivers

Front 25

- if you have a member function that should not change the value of a calling object, you can mark

the function with the const modifier
- the computer will issue an error message if your function code changes the value of the calling

object

Back 25

const function modifier

Front 26

- if you are using a call-by-reference parameter and the function does not change the value of the

parameter, you can mark the parameter so that the compiler knows that the parameter should not be

changed
- place the modifier const before the parameter type

Back 26

const call-by-reference parameter

Front 27

- can be used as if they were literal values of type string
- s3 = "Hello Mom!";
- strings in double quotes
- just an array of characters
- terminated by '\0' null character
- char aString[10]; strcpy(aString, "Hello"); // legal
- can be output with <<

Back 27

C-strings

Front 28

- size of first dimension is not given (because it's a pointer?)

Back 28

multidim array parameters for function headings

Front 29

- automatic type casting of quoted strings to type string
- strcpy
- strcmp
- strcat
- strlen

Back 29

strings

Front 30

- created using the new operator
- p1 = new int;
- has no identifier
- created and destroyed while the program is running

Back 30

dynamically allocated variables

Front 31

- memory address
- can be stored in a variable
- cannot store in variable of type int or double, must have pointer type
- must be asterisk before each pointer declaration
- the asterisk (*) is called the dereferencing operator. it produces the variable to which it points
- the ampersand (&) in front of an ordinary variable produces the address. it is called the

address-of operator
- double *p, v; p = &v; *p = 9.99;

Back 31

pointers

Front 32

- size not specified when you write the program
- size determined while the program is running
- created with new
- d = new double[10];
int arraySize;
cout << "How many?";
cin >> arraySize;
intPtr a;
a = new int[arraySize];
.
.
.
delete [] a;

Back 32

pointer arithmetic

Front 33

- allows you to read in one character at a time
- takes one argument, should be char
- will read blank or new line if that is next character

Back 33

cin.get