C Program Notes

www.onlineeducation.bharatsevaksamaj.
net
www.bssskillmission.in
N
I
.
E
C++
(&
C)
Grab
Bag
V
S
S
.B
www.bsscommunitycollege.in www.bssnewgeneration.in www.bsslifeskillscollege.in
www.onlineeducation.bharatsevaksamaj.net
N
I
.
Final Project:
Due in 2 Days
E
V
S
Complete
Something
S
.B
W
W
N
I
.
E
Parent
destructors
V
S
S
.B
struct Buffer {
Buffer(int s) { buf = new char[s]; }
~Buffer() { delete [] buf; }
char *buf;
};
struct FBuffer : Ipublic
Buffer {
N
.
E : Buffer(s) {
FBuffer(int Vs)
S
f = fopen("file",
"w");
S
B
.
}
W
W
~FBuffer()
{
fclose(f);
}
W
void write() { fwrite(buf, 1, 40, f); }
FILE *f;
};
4
struct FBuffer
: public Buffer {
FBuffer(int s);
~FBuffer();
void write();
FILE *f;
};
struct Buffer {
Buffer(int s);
~Buffer();
char *buf;
};
N
I
.
E
V
S
S
.B
BufferW*buf = new Buffer(128);
W
delete buf;
//
struct FBuffer
: public Buffer {
FBuffer(int s);
~FBuffer();
void write();
FILE *f;
};
struct Buffer {
Buffer(int s);
~Buffer();
char *buf;
};
N
I
.
E
V
S
S
.B
W *fbuf = new FBuffer(128);
FBuffer
W
delete fbuf;
//
Construction
Buer
N
I
(buf)
.
E
V
S
S
Uninitialized
.B
W
W
W
Uninitialized
Buer
(buf)
FBuer
(f)
Destruction
Buer
(buf)
Buer
N
I
(buf)
.
E
V
S
S
.B
Uninitialized
W
FBuer
(f)
Uninitialized
struct FBuffer
: public Buffer {
FBuffer(int s);
~FBuffer();
void write();
FILE *f;
};
struct Buffer {
Buffer(int s);
~Buffer();
char *buf;
};
N
I
.
E
V
S
S
.B
BufferW*fbuf = new FBuffer(128);
W
delete fbuf;
// only ~Buffer is called
10
struct FBuffer
struct Buffer {
: public Buffer {
Buffer();
FBuffer();
virtual ~Buffer(); virtual ~FBuffer();
char *buf;
void write();
};
FILE *f;
IN };
.
E
V
S
S
.B
BufferW*fbuf = new FBuffer;
W
delete fbuf;
//
10
11
N
I
.
E
C++
Casts
V
S
S
.B
11
12
// C cast
char *buf = (char *)malloc(128);
// C-style cast
float b = 98.6;
int a = int(b);
N
I
.
E
V
S
S
.B
12
13
// C-style cat casts
class Cat { };
class Tiger : public Cat { };
class Persian : public Cat { };
Cat *c = new Persian;

Tiger *t = (TigerN*)c; // whoops!
I
.
E
V
S
S
.B
Cat
Tiger
Persian
13
14
// valid up-cast
Tiger *t = new Tiger;

Cat *c1 = (Cat *)t;
Cat *c2 = static_cast<Cat

*>(t);
N
I
.
Cat *c3 = dynamic_cast<Cat
*>(t);
V
S
S
.B
14
15
// almost valid down-cast
Cat *c = new Tiger;
Tiger *t1 = (Tiger *)c;
Tiger *t2 = static_cast<Tiger

*>(c);
N
I
.
Tiger *t3 = dynamic_cast<Tiger
*>(c);
V
S
S
.B
// compile
error
15
16
// valid down-cast
class Cat { virtual void purr() { } };
class Tiger : public Cat { };
class Persian : public Cat { };
N
I
.
Cat *c = new Tiger;
E
V
S
S
B
.
Tiger *t1
=
(Tiger
*)c;
W
Tiger W
*t2 = static_cast<Tiger *>(c);
W
Tiger *t3 = dynamic_cast<Tiger *>(c);
16
17
// invalid down-cast
Cat *c = new Persian;
Tiger *t1 = (Tiger *)c;
Tiger *t2 = static_cast<Tiger

*>(c);
N
I
.
Tiger *t3 = dynamic_cast<Tiger
*>(c);
V
S
S
.B
// t1 & W
t2 are invalid pointers
// t3 W
is NULL
17
18
N
I
.
E
References
V
S
S
.B
18
19
void swap(int *a, int *b) {

int tmp = *a;
*a = *b;
*b = tmp;N
I
.
}
E
V
S
S
.B
int main() {
W
W int x = 2, y = 3;
W swap(&x, &y);
}
19
20
void swap(int &a, int &b) {

int tmp = a;
a = b;
b = tmp; N
I
.
}
E
V
S
S
.B
int main() {
W
W int x = 2, y = 3;
W swap(x, y);
}
20
21
N
I
.
E
Hello,
World!
V
S
S
.B
21
22
#include <iostream>
N
int main() {
I
.
E
std::cout
<< "Hello, World!"
V
S
S
<<
std::endl;
B
.
W
return
0;
W
W}
22
23
#include <iostream>
N
int main() {
I
.
E
std::cout
<< "Hello, World!"
V
S
S
<<
std::endl;
B
.
W
return
0;
W
W}
23
24
N
I
.
E
Namespaces
V
S
S
.B
24
25
SNDFILE *open(const char *);

count_t seek(SNDFILE *, count_t);
int error(SNDFILE *);
N
I
.
E
V
S
S
.B
25
26
SNDFILE *sf_open(const char *);

count_t sf_seek(SNDFILE *, count_t);
int sf_error(SNDFILE *);
N
I
.
E
V
S
S
.B
26
27
namespace sf {
SNDFILE *open(const char *);
count_t seek(SNDFILE *, count_t);
int error(SNDFILE *);
}
N
I
.
E
V
S
S
.B
27
28
#include <iostream>
N
int main() {
I
.
E
std::cout
<< "Hello, World!"
V
S
S
<<
std::endl;
B
.
W
return
0;
W
W}
28
29
std::cout << "Hello, World!"

<< std::endl;
using namespace std;
N
cout << "Hello,
World!"
I
.
E
<< Vendl;
S
S
.B
W std::cout;
using
W
Wusing std::endl;
cout << "Hello, World!"
<< endl;
29
30
g++ -E hello.cpp
iostream
namespace std {
N
extern
istream cin;
I
.
E
extern
ostream cout;
V
S
S
extern
ostream
cerr;
B
.
W}
30
31
namespace std {
N
extern
istream cin;
I
.
E
extern
ostream cout;
V
S
S
extern
ostream
cerr;
B
.
class ActionLawsuit {
};
31
32
N
extern
istream cin;
I
.
E
extern
ostream cout;
V
S
S
extern
ostream
cerr;
B
.
};
32
33
namespace super {
namespace std {
N
extern
istream cin;
I
.
E
extern
ostream cout;
V
S
S
extern
ostream
cerr;
B
.
};
super::std::ActionLawsuit;

33
34
N
I
.
E
extern
V
S
S
.B
34
35
iostream
namespace std {
N
extern
istream cin;
I
.
E
extern
ostream cout;
V
S
S
extern
ostream
cerr;
B
.
W}
35
36
iostream
ostream cout;
main.c
foo.c
N
I
.
E
V
#include <iostream>
S
#include <iostream>
W {
int main()
W
W << "i";
cout
foo();
}
int foo() {
cout << "Phone";
}
S
.B
36
37
main.c (preprocessed) foo.c (preprocessed)
ostream cout;
ostream cout;
int main() {
cout << "i";
foo();
N
I
.
E
}
V
int foo() {
cout << "Phone";
}
S
S
.B
main.o W
foo.o
cout
cout
main
foo
ld: 1 duplicate symbol for architecture x86_64
37
38
main.c (preprocessed) foo.c (preprocessed)

extern ostream cout; extern ostream cout;
int main() {
cout << "i";
foo();
N
I
.
E
}
V
int foo() {
cout << "Phone";
}
S
S
.B
main.o W
foo.o
main
foo
<standard library>
cout
38
39
#include <iostream>
N
int main() {
I
.
E
std::cout
<< "Hello, World!"
V
S
S
<<
std::endl;
B
.
W
return
0;
W
W}
39
40
#include <iostream>
N
int main() {
I
.
E
std::cout
<< "Hello, World!"
V
S
S
<<
std::endl;
B
.
W a = 2 << 1;
int
Wreturn 0;
W
}
40
41
N
I
.
E
Operator
Overloading
V
S
S
.B
41
42
struct vec2 {
vec2(float x, float y)
: x(x), y(y) { }
float x, y;
};
N
I
.
E
int main() V{
S
S
vec2 .a(1,
0);
B
W b(1, 3);
vec2
W
Wvec2 c = a + b; // compile error
}
vec.cpp: In function int main():
vec.cpp:12: error: no match for operator+ in a + b
42
43
vec2 vec2::add(const vec2 &o) {

return vec2(x + o.x, y + o.y);
}
int main() {
N 3);
vec2 a(1, 0), .b(1,
I
E
vec2 c = a.add(b);
V
S
S
}
.B
43
44
vec2 vec2::operator +(const vec2 &o) {

}
int main() {
N 3);
vec2 a(1, 0), .b(1,
I
E
vec2 c = a V
+ b;
S
vec2 d =.BS
a.operator+(b);
W
}
44
45
vec2 operator +(vec2 &v, const vec2 &o) {

}
int main() {
N
vec2 a(1, 0), b(1,
3);
I
.
E
vec2 c = a +Vb;
S
S
}
.B
45
a
a
a
a
a
a
a
a
a
a
46
+ b
a != b
- b
a && b
* b
a || b
/ b
a & b
% b
a | b
< b
a ^ Nb
I
.
<= b
aE<< b
V
S
== b
a >> b
S
B
.
>= b
a,
b
W
>W
b
a[b]
vec2 operator+(const vec2 &o);
46
47
+a
-a
++a
a++
--a
a-N
I
.
!a
E
V
S
~a
S
B
.
*a
W
&a W
vec2 operator+();
47
a
a
a
a
a
a
48
= b
+= b
-= b
*= b
/= b
%= b
a
a
a
a
a
a
&= b
|= b
^= b
<<= b
>>= b
= N(b += c)
I
.
E
V
S
S
.B
vec2 &vec2::operator+=(const vec2 &o)

W
{ W
Wx += o.x;
(this is a pointer
y += o.y;
to the object)
return *this;
}
48
49
N
I
.
E
Streams
V
S
S
.B
49
50
struct Foo {
char *str() const {
return "Foo!";
}
};
N
ostream &
I
.
E
operator<<(ostream
&os, const Foo &f) {
V
S
S
return os
<<
f.str();
B
.
W
}
W
int main() {
Foo f;
std::cout << f << std::endl;
}
50
MIT OpenCourseWare
http://ocw.mit.edu
6.S096 Introduction to C and C++

IAP 2013
For information about citing these materials or our Terms of Use, visit: http://ocw.mit.edu/terms.
N
I
.
E
V
S
S
.B
51
6.S096: Introduction to C/C++

Frank Li, Tom Lieber, Kyle Murray
N
I
.
E
Lecture
8:
V
S
S
Last
Lecture
B
.
Helter
W Skelter Fun!
January 31, 2012
52
Today
Standard Template Library (STL)
Crazay Const
Exceptions
Function pointers
N
I
.
E
V
S
S
.B
Brief intro to C++11
53
Today
Crazay Const
Exceptions
Function pointers
N
I
.
E
V
S
S
.B
54
Included w/ compiler
Contains containers/data structures, iterators,
and algorithms
http://www.cplusplus.com/reference
N
I
.
E
V
S
S
.B
55
Vectors
Equivalent to array lists in other languages

(dynamic size)
#include <vector>
std::vector<int> int_list;
int_list.push_back(1);
N
I
.
E
V
S
int tmp = int_list[0]; //
tmp = 1
S
B
.
int_list.pop_back(); // int_list now empty
W
W
W
56
57
Map
00
John Smith
Like a dictionary in Python (tree

implementation).
01
521-8976
02
521-1234
03
Lisa Smith
13
Sandra Dee
14
521-9655
15
#include <map>
Keys
Hash
Function
Buckets
Image by MIT OpenCourseWare.
std::map<char, int> letter_to_int;
letter_to_int['a'] = 1;
N
I
.
E
V
letter_to_int['b'] = 2;
S
S
B
.
int pos = letter_to_int['a'] // pos = 1;
W
W
W
Others Containers
Other useful containers:

<array>: array w/ functions
<list>: doubly linked list
<set>: stores only unique elements, tree

implementation
<unordered_map>: actual hash table
<unordered_set>: stores only unique
elements, hash table implementation
N
I
.
E
V
S
S
.B
Look online for more!
58
Iterators
Object that points to elements in a data

structure, and can iterate through. Like a
pointer.
Vector iterator: std::vector<int>::iterator it;
N
I
.
E
Access element at iterator: *it;
V
S
S
.B
Can do add/subtract to iterators: it++, it--
59
Vector Iterators
#include <vector>
#include <iostream>
...
std::vector<int> vec;
for (int i=1; i<=5; i++)
vec.push_back(i);
N
I
.
E
for (std::vector<int>::iterator it = vec.begin();

it != vec.end(); ++it){
S
.B
std::cout << ' ' << *it;
W
1 2 3 4 5
//Will print:W
W
}
V
S
60
Cool/Useful Algorithm
#include <algorithm>
Sort a vector:
Reverse a vector:
std::reverse(vec.begin(), vec.end());
Min/Max:
std::sort(vec.begin(), vec.end());
N
I
.
E
V
S
std::min(3,1) == 1 ; std::max(3,1) == 3
S
So many more online!
.B
W
W
W
61
Today
Crazay Const
Exceptions
Function pointers
N
I
.
E
V
S
S
.B
62
Const Madness!
const int x == int const x;
// Const int
const int * c1;
// Pointer to const int
N
I
.
E
V
int const * c2; // Same
as c1
S
S
.B
W
int * constW
c3; // Const pointer to variable int
W
63
More Const Madness!
Const in function parameter

bool cant_touch_this(const myobj & obj);
//cant_touch_this can't modify obj
Const functions are safe for const objects, but can

be called by all objects. Non-const functions can
only be called by non-const objects.
N
I
.
E
V
S
bool catch_change_this()
const {
S
B
.
...
W
}
W
W
64
When will the madness end!?!?

const int* const
crazay(const int* const & madness) const;
N
I
.
E
V
S
S
.B
65
Today
Crazay Const
Exceptions
Function pointers
N
I
.
E
V
S
S
.B
66
Exceptions
Exceptions are error objects that are thrown

when things go bad.
N
I
.
E
V
S
S
.B
67
Exceptions
Exception parent object in std::exception
std::runtime_error
std::bad_alloc
std::bad_cast
Can create your own custom exceptions

class MyException : public exception{
N
I
const char * what() const { E.
V
S
return "MyException";
// human-readable
S
.B
}
W
};
W
W
68
Try Catch
try {
// Protected code
throw MyError();
}catch( YourError e1 ){
cout << e1.what() << endl;
N
I
.
E
}catch( MyError e2 ){
cout << e2.what() << endl;
V
S
S
.B
}catch(...) {
// handle all other exceptions

}
69
Throwing that Exceptions
Can throw a primitive as an exception

try{
...
throw 20;
}catch(int e) { cout << Error: << e << endl; }
Best way to catch your own exception:

try{
N
I
.
E
V
S
throw MyException();
S
.B
}catch(MyException & e) {
cout << e.what() << endl;
70
Functions Throwing
Functions add throw(exceptions-thrown) at end

of declaration.
void ahh(int i) throw() {
//This function assumed to not throw anything
N
I
void blahh(int i) throw(int) { .
E
V
//This function may throw
int if there's an error
S
S
}
.B
W
W
W
71
Today
Crazay Const
Exceptions
Function pointers
N
I
.
E
V
S
S
.B
72
Functions Pointers
void (*foo) (int); // Foo is pointer to void

function that takes 1 int argument.
void *(*foo)(int *, char); //Any guesses?
N
I
.
E
V
S
S
.B
73
Functions Pointers
void (*foo) (int); // Foo is pointer to void
function that takes 1 int argument.
void *(*foo)(int *, char); //Foo is a pointer to a

function that takes 1 int* argument and 1 char
argument, that returns void*
N
I
.
E
V
S
S
.B
74
Using Functions Pointers
#include <iostream>
void my_int_func(int x){
std::cout << x << std::endl;
}
int main(){
void (*foo)(int);
N
I
.
(*foo)(2); // Calls my_int_func E
V
foo(2); // Same as above line
S
S
return 0;
B
.
}
W
W
W
foo = &my_int_func; // The ampersand is actually optional
75
Functions Pointers Arguments
#include <iostream>
void call(int x){

}
void call_me_maybe(int number, void (*call_func)(int)) {
call_func(number);
N
I
.
E
int main(){
void (*foo)(int);
V
S
foo = call;
S
.B
call_me_maybe(911, foo);
return 0;
76
Functions Pointers Arguments
#include <iostream>
void call(int x){
}
void call_me_maybe(int number, void (*call_func)(int)) {
call_func(number);
N
I
.
E
V
S
int main(){
S
.B
call_me_maybe(911, call);
return 0;
}
77
For_each
#include <algorithm> // Header file need for for_each()
#include <vector>
#include <iostream>
void print (int i) { cout << ' ' << i; }
int main(){
N
I
.
E
vector<int> myvector;
myvector.push_back(10);
V
S
myvector.push_back(20);
S
.B
for_each (myvector.begin(), myvector.end(), print);
W
} // Prints W
out 10 20
W
...
78
Today
Crazay Const
Exceptions
Function pointers
N
I
.
E
V
S
S
.B
79
C++11
Latest and greatest standard of C++ w/ fancy

features
Fancy feature 1: Auto typing
N
I
.
E
int x = 1;
auto y = x;
V
S
S
.B
vector<int> vec;
auto itr = vec.begin(); //versus vector<int>::iterator
80
C++11

features
Fancy feature 2: Declare typing
int x = 1;
N
I
.
E
decltype(x) y = x; //Makes y the same type as x
V
S
S
.B
81
C++11

features
Fancy feature 3: Right angle brackets

Before C++11:
N
I
.
E
vector<vector<int> > vector_of_int_vectors;

C++11:
V
S
vector<vector<int>>
vector_of_int_vectors;
S
.B
W
W
W
82
C++11

features
Fancy feature 4: Range for loops
vector<int> vec;
N
I
.
E
vec.push_back( 1 );
vec.push_back( 2 );
V
S
S
.B
for (int& i : vec ) {
i++; // increments the value in the vector

}
83
C++11
Latest and greatest standard of C++ w/ fancy features
Fancy feature 5: Lambda functions!!!
Syntax: [] (arg_list) { func_definition }
Ex:
#include <iostream>
int main(){
auto func = [] (int i) { cout << "Hi " << i << endl; };
func(1); // now call the function
}
N
I
.
E
V
S
S
.B
84
C++11
Many more fancy features (strongly typed
enums, null pointer constant, etc)!
\(^_^) /
Yay!!!
N
I
.
E
Reference:
V
S
http://www.cprogramming.com/tutorial.html#c++11
S
.B
http://en.wikipedia.org/wiki/C%2B%2B11
85
It's about that time...
Introduced you to C and C++ syntax, features, and

idoms.
Gave you some experience w/ writing C/C++ code
Much more to learn, best way is to simply code more!
N
I
.
E
V
S
S
.B
86
MIT OpenCourseWare
http://ocw.mit.edu

IAP 2013
N
I
.
E
V
S
S
.B
87
N
I
.
E
C++
Inheritance
V
S
S
.B
88
N
I
.
E
Bits
&
Bobs
V
S
S
.B
89
90
int x;
int y;
int
int
pt
pt.x
N
pt.y
I
.
struct {
int x;
E
int y;
V
S
S
} pt;
B
int
int
W
union {
int x;
int y;
} pt;
pt
pt.x
pt.y
int
int
91
foo
foo.x
N
foo.y
I
.
union {
struct {
int a;
E
char b;
V
S
S
} x;
.B
W
foo.x.a
intWy;
W
} foo;
foo.x.b
int
char
int
N
I
.
E
Why
Inheritance?
V
S
S
.B
92
93
struct Circle {
int x, y;
int radius;
void draw();
};
struct Square {
int x, y;
int width;
void draw();
};
N
I
.
E
V
S
S
.B
94
struct Circle {
int x, y;
int radius;
void draw();
};
struct Square {
int x, y;
int width;
void draw();
};
N
I
.
E
Circle *circles[nc];
V
S
S
Square *squares[ns];
.B
95
struct Circle {
int x, y;
int radius;
void draw();
};
struct Square {
int x, y;
int width;
void draw();
};
N
I
.
E
V
S
S
.B
W i = 0; i < nc; i++)

for(int
circles[i].draw();
for(int i = 0; i < ns; i++)
squares[i].draw();
for(int i = 0; i < nc; i++)

circles[i].draw();
for(int i = 0; IiN < ns; i++)
.
E
squares[i].draw();
V
S
S
.B
Wi = 0; i < nc; i++)

for(int
W
W
delete
circles[i];
delete squares[i];
for(int i = 0; i < nc; i++)
96
97
struct Circle {
int x, y;
int radius;
void draw();
};
?
N
I
.
E
Shape *shapes[ns];
V
S
struct Square {
int x, y;
int width;
void draw();
};
?
S
.B
W
for(int
W i = 0; i < ns; i++)
W
shapes[i].draw();
delete shapes[i];
N
I
.
E
Inheritance
V
S
S
.B
98
99
class Shape {
public:
virtual void draw() = 0;
};
class Circle : public Shape {
private:
N
I
.
int x, y;
E
V
S
int radius;
S
public: .B
W
virtual
W void draw();
}; W
void Circle::draw() {
...
}
e
c
i
ct
N
I
1)ESubclassing
.
V
S
S 2) virtual
.B
100
N
I
1)ESubclassing
.
V
S
S 2) virtual
.B
101
1) Subclassing
N
I
.
E
V
S
S
.B
inherit
behavior
from
the
parent
W
102
class Shape {
public:
void draw();
};

public:
N
I
.
int getRadius();
E
V
S
};
S
.B
W
int main()
{
W
W
Circle
circle;
}
circle.draw();
103
Shape
Circle : public Shape
void draw()
N
I
.
E
V
S
S
.B
104
void draw()
int getRadius()
1) Subclassing
N
I
.
E
V
S
S
.B
inherit
elds
from
the
parent
W
105
class Shape {
public:
int x, y;
};

public:
N
I
int radius; E.
V
S
};
S
.B
W
int main()
{
W
W
Circle
circle;
}
circle.x = 5;
106
Shape
Circle : public Shape
int x
N
I
.
E
V
S
S
int .y
107
int x
int y
int radius
Shape
int x
E
V
S
S
.B
int y
N
.I
int radius
is-a or has-a?
108
Circle
109
class Circle
: public Shape {
N
public:
I
.
int radius; VE
S
S
};
.B
class Circle {
public:
Shape shape;
int radius;
};
110
class Circle
: public Shape {
N
public:
I
.
int radius; VE
S
S
};
.B
class Circle {
public:
Shape shape;
int radius;
};
W
circle.x;
W
circle.shape.x;
1) Subclassing
N
I
.
E
V
S
S
.B
public/protected/private
elds
W
111
112
class Shape {
public:
int x;
private:
int y;
};
only accessible in
Shape class
N
I
.
void Circle::foo()
E
V
S
printf("%d",
x);
S
.B
printf("%d",
y);
W
}
W
W
{
// compile error
113
class Shape {
public:
int x;
protected:
int y;
};
accessible in Shape class

and in subclasses
N
I
.
void Circle::foo()
{
E
V
S
printf("%d",
x);
S
.B
printf("%d",
y);
W
}
W
W
int main() {
Circle circle;
circle.x = 0; // compile error
}
1) Subclassing
N
I
.
E
V
S
S
.B
public/protected/private
inheritance
W
114
class Shape {
public:
void draw();
};

};
N
I
.
E
V
S
S
.B
115
class Shape {
public:
void draw();
};
class Circle : protected Shape {

};
N
I
.
E
V
S
S
.B
116
class Shape {
public:
void draw();
};
class Circle : protected Shape {

protected:
N
I
.
int getRadius();
E
V
S
};
S
.B
W
The W
inheritance is protected.
If you can access getRadius(),

you can access draw()
117
class Shape {
public:
void draw();
};
class Circle : private Shape {

private:
N
I
.
int getRadius();
E
V
S
};
S
.B
W
The W
inheritance is private.
If you can access getRadius(),

you can access draw()
118
N
I
.
private
inheritance:
E
V
S
is-a
or
has-a
S
.B
119
1) Subclassing
N
I
.
E
V
S
S
.B
multiple
inheritance
W
120
class Color {
public: virtual void print();
};
class Mood {
public: virtual void print();
};
IN
.
E
V
S
class Blue B:S public Color, public Mood {

.
public: W
W void print() {
virtual
W
this->Color::print();
this->Mood::print();
}
};
121
122
1) Subclassing
N
I
.
E
V
S
S
.B
slicing
struct Cow {
void speak() {
printf("Moo.\n");
}
};
N
struct Werecow
: public Cow {
I
.
E
bool transformed;
V
S
S
void
speak()
{
B
.
Wif (transformed)
W
printf("Aaooooh!\n");
W
else
printf("Moo.\n");
}
};
123
Werecow wcow;
wcow.transformed = true;
Cow cows[2];
cows[0] = Cow();
cows[1] = wcow;
N
I
.
E
for (int
i = 0; i < 2; i++)
V
S
S
cows[i].speak();
.B
W
wcow.speak();
// Output:
Moo.
//
//
Moo.
//
Aaooooh!
124
void poke(Cow cow) {

cow.speak();
}
Cow judy;
Werecow bev;
bev.transformed
=
true;
I
.
E
V
S
poke(judy);
S
.B
poke(bev);
W
bev.speak();
// Output:
//
Moo.
//
Moo.
Aaooooh!
//
125
Cow
N
I
.
E
V
S
S
.B
126
Werecow
bool transformed
N
I
Use
pointers
.
E
V
S
Use
virtual
S
.B
127
N
I
1)ESubclassing
.
V
S
S 2) virtual
.B
128
class Shape {
public:
void draw() { printf("shape\n"); }
};
public:
N
I
void draw() {E.printf("circle\n"); }
V
S
};
S
.B
129
class Shape {
public:
};
public:
N
I
V
S
};
S
.B
W
CircleW*circle = new Circle;
W
circle->draw();
// "circle"
130
class Shape {
public:
};
public:
N
I
V
S
};
S
.B
W
Shape W
*shape =
W
shape->draw();
new Circle;
// "shape"
131
class Shape {
public:
};
public:
N
I
V
S
};
S
.B
W
Shape W
*shape =
W
shape->draw();
new Circle;
// "shape"
draw() is non-virtual,
so its compiled like a C call
132
Non-virtual functions are
determined at compile-time
class Cat {
public:
void yawn(int
duration);
N
I
.
};
E
V
S
S
.B
CatWcat, *pcat = new SuperCat;
W
cat.yawn(4);
Wpcat->yawn(4);
Both use Cat::yawn
because both have type Cat
133
134
Virtual functions are

determined at run-time
class Cat {
public:
virtual void Nyawn(int duration);
I
.
};
E
V
S
S
.B
Cat cat,
*pcat
=
new
SuperCat;
W
W
cat.yawn(4);
W
pcat->yawn(4);
Use Cat::yawn and SuperCat::yawn

(pcats type is checked every time its called)
N
I
non-virtual:
compile-time
.
E
V
S
S
virtual:
run-time
B
.
135
2) N
virtual
I
.
E
V
S
S
.B
pure
virtual
methods
W
136
137
class Shape {
public:

};
N
I
int main()
{
.
E
V
Shape
shape;
S
S
}
.B
W
pure.cpp: In function int main():
pure.cpp:7: error: cannot declare variable shape to be of abstract type Shape
pure.cpp:1: note:
because the following virtual functions are pure within Shape:
pure.cpp:3: note: ! virtual void Shape::draw()
class Drawable {
public:
};
class Fish : public Drawable {
public:
N
I
.
virtual void
draw();
E
V
S
};
S
.B
W
intWmain()
WDrawable
{
*drawables[3];
drawables[0] = new Fish;
drawables[1] = new Salami;
drawables[2] = new JackSparrow;
138
2) N
virtual
I
.
E
V
S
S
.B
destructors
139
Make virtual destructors
class Fish {
public:
Fish() {
gills[0] = new Gill;
N
I
gills[1]
=
new
Gill;
.
E
} SV
S
B
~Fish() {
.virtual
W delete gills[0];
W
W
delete gills[1];
}
private:
Gill *gills[2];
};
140
2) N
virtual
I
.
E
V
S
S
.B
virtual inheritance
141
142
class Goofball {
int x;
};
class Stupid : public Goofball { };
class Dumb : public Goofball { };
N
I
.
E
class Oops : public

Stupid, public Dumb {
V
S
S
};
B
Oops
Stupid::x
Dumb::x
class Goofball {
int x;
};
class Stupid : public Goofball { };
class Dumb : public Goofball { };
N
I
.
E
class Oops : public

V
S
S
int fail();
B
.
};
W
int Oops::fail() {
Stupid::x = 1; Dumb::x = 2;
return Stupid::x + Dumb::x; // 3
}
143
144
class Goofball {
int x;
};
class Stupid : virtual public Goofball { };
class Dumb : virtual public Goofball { };
N
I
.
E
class Oops : public

V
S
S
int fail();
B
.
};
W
int Oops::fail() {
Stupid::x = 1; Dumb::x = 2;
return Stupid::x + Dumb::x; // 4
}
N
I
.
E
Conclusion
V
S
S
.B
145
146
class Shape {
public:
};
private:
N
I
.
int x, y;
E
V
S
int radius;
S
public: .B
W
virtual
W void draw();
}; W
void Circle::draw() {
...
}
e
c
i
ct
MIT OpenCourseWare
http://ocw.mit.edu

IAP 2013
N
I
.
E
V
S
S
.B
147
6.S096: Introduction to C/C++

Frank Li, Tom Lieber, Kyle Murray
N
I
.
E
V
S
S
Lecture 3: C.B
Memory Management
WJanuary 15, 2013
W
W
1
148
Today
Computer Memory
Pointers/Addresses
N
I
.
E
Arrays
V
S
S
.B
Memory Allocation
149
Today
Computer Memory
Pointers/Addresses
N
I
.
E
Arrays
V
S
S
.B
Memory Allocation
150
Heap
Heap is a chunk of memory that users can use to
dynamically allocated memory.
Lasts until freed, or program exits.
N
I
.
E
V
S
S
.B
151
152
Stack
Stack contains local variables from functions and

related book-keeping data. LIFO structure.
Function variables are pushed onto stack when
called.
Functions variables are popped off stack when
return.
N
I
.
E
V
S
S
.B
Memory Layout
N
I
.
E
V
S
S
.B
Memory Layout diagram courtesy of bogotobogo.com, and used with permission.
153
Call Stack
Example: DrawSquare called from main()
void DrawSquare(int i){

int start, end, . //other local variables
DrawLine(start, end);
}
N
I
.
E
void DrawLine(int start, int end){
//local variables
V
S
S
.B
...
154
155
Call Stack
Lower address
Example:
int start, end, ...
}
N
I
.
E
void DrawLine(int start,

int end){
//local variables
S
.B
...
}
V
S
Top of Stack
Higher address
156
Call Stack
Lower address
Example:
int start, end, ...
}
int end){
//local variables
S
.B
...
V
S
Top of Stack
int i (DrawSquare arg)
N
I
.
E
Higher address
157
Call Stack
Lower address
Example:
int start, end, ...
}
N
I
.
E

int end){
//local variables
S
.B
...
}
V
S
main() book-keeping
Top of Stack
10
Higher address
158
Call Stack
Lower address
Example:
int start, end, ...
Top of Stack
N
I
.
E
local variables (start, end)

int end){
//local variables
S
.B
...
}
V
S
DrawSquare
stack frame
main() book-keeping
11
Higher address
159
Call Stack
Lower address
Example:
int start, end, ...
Top of Stack
start, end (DrawLine args)
N
I
.
E

int end){
//local variables
S
.B
...
}
V
S
DrawSquare
stack frame
main() book-keeping
12
Higher address
160
Call Stack
Lower address
Example:
Top of Stack
int start, end, ...
DrawSquare book-keeping
N
I
.
E

int end){
//local variables
S
.B
...
}
V
S
DrawSquare
stack frame
main() book-keeping
13
Higher address
161
Call Stack
Lower address
Top of Stack
Example:
DrawLine local vars
DrawLine
stack
frame
int start, end, ...
int end){
//local variables
DrawSquare
stack frame
S
.B
...
V
S
main() book-keeping
N
I
.
E
14
Higher address
162
Call Stack
Lower address
Top of Stack
Example: DrawLine returns
DrawLine local vars
DrawLine
stack
frame
int start, end, ...
int end){
//local variables
DrawSquare
stack frame
S
.B
...
}
V
S
main() book-keeping
N
I
.
E
15
Higher address
163
Call Stack
Lower address
Example: DrawLine returns

int start, end, ...
Top of Stack
N
I
.
E

int end){
//local variables
S
.B
...
}
V
S
DrawSquare
stack frame
main() book-keeping
16
Higher address
164
Call Stack
Lower address
Example: DrawSquare returns

int start, end, ...
}
Top of Stack
N
I
.
E

int end){
//local variables
V
S
DrawSquare
stack frame
S
.B
...
main() book-keeping
17
Higher address
165
Call Stack
Lower address
Example: DrawSquare returns

int start, end, ...
}
N
I
.
E
int end){
//local variables
V
S
S
.B
...
Top of Stack
18
Higher address
Today
Computer Memory
Pointers/Addresses
N
I
.
E
Arrays
V
S
S
Memory Allocation
.B
W
W
W
19
166
Pointers and Addresses
N
I
.
E
V
S
S
.B
Courtesy of xkcd at http://xkcd.com/138/, available under a CC by-nc license

20
167
168
Addresses
Each variable represents an address in memory

and a value.
Address: &variable = address of variable
N
I
.
E
&X = SSVAddress of X
.B
Image by MIT OpenCourseWare.

21
Pointers
A pointer is a variable that points to the block

of memory that a variable represent.
Declaration: data_type *pointer_name;
Example:
char x = 'a';
N
I
.
E
char *ptr = &x; // ptr points to a char x
V
S
S
.B
22
169
Pointers
A pointer is a variable that points to the block

of memory that a variable represent.
Declaration: data_type *pointer_name;
Example:
char x = 'a';
N
I
.
E
char *ptr = &x; // ptr points to a char x

Pointers are integer variables themselves, so can
have pointer to pointers: char **ptr;
V
S
S
.B
23
170
171
Data type sizes

Name
char
Description
Character or small
integer.
Size*
Range*
signed: -128 to 127
unsigned: 0 to 255
1byte
short int (short) Short Integer.
2bytes
signed: -32768 to 32767

unsigned: 0 to 65535
int
Integer.
4bytes
signed: -2147483648 to 2147483647

long int (long)
Long integer.
4bytes
signed: -2147483648 to 2147483647

bool
Boolean value. It can

take one of two values: 1byte
true or false.
float
Floating point number. 4bytes
+/- 3.4e +/- 38 (~7 digits)
double
Double precision
8bytes
floating point number.
+/- 1.7e +/- 308 (~15 digits)
long double
N
I
.
E
V
S
S
.B
Long double precision

floating point number.
true or false
8bytes
+/1.7e +/- 308 (~15
www.bsscommunitycollege.in www.bssnewgeneration.in
www.bsslifeskillscollege.in
24
digits)
172
Dereferencing = Using Addresses

Also uses * symbol with a pointer. Confusing? I know!!!
Given pointer ptr, to get value at that address, do: *ptr
int x = 5;
int *ptr = &x;
*ptr = 6; // Access x via ptr, and changes it to 6
N
I
.
E
printf(%d, x); // Will print 6 now
V
S
Can use void pointers, just cannot
dereference without casting
S
.B
W
W
W
25
173
Pointer Arithmetic
Can do math on pointers
Ex: char* ptr
ptr
a
N
I
.
E
V
S
S
.B
26
174
Pointer Arithmetic
Ex: char* ptr
ptr + 1
N
I
.
E
V
S
S
.B
27
175
Pointer Arithmetic
Ex: char* ptr
ptr + 1
N
I
.
E
V
S
S
.B
ptr+i has value: ptr + i * sizeof(data_type of ptr)
28
Pointer Arithmetic
p1 = p2: sets p1 to the same address as p2
Addition/subtraction:
p1 + c , p1 - c
Increment/decrement:
N
I
.
E
p1++, p1--
V
S
S
.B
29
176
Why use pointers? They so confuzin
Pass-by-reference rather than value.

void sample_func( char* str_input);
Manipulate memory effectively.
N
I
.
E
Useful for arrays (next topic).
V
S
S
.B
W
W
W
30
177
Today
Computer Memory
Pointers/Addresses
N
I
.
E
Arrays
V
S
S
Memory Allocation
.B
W
W
W
31
178
C Arrays (Statically Allocated)
Arrays are really chunks of memory!

Declaration:
Data_type array_name[num_elements];
N
I
.
E
Declare array size, cannot change.
V
S
S
.B
32
179
C Arrays (Statically Allocated)
Can initialize like:

int data[] = {0, 1, 2}; //Compiler figures out size
int data[3] = {0, 1, 2};
int data[3] = {1}; // data[0] = 1, rest are set to 0
int data[3]; //Here, values in data are still junk
N
I
.
E
data[0] = 0;
V
S
data[1] = 1;
S
.B
data[2] = 2;
33
180
Array and Pointers
Array variables are pointers to the array start!
char *ptr;
char str[10];
ptr = str; //ptr now points to array start
ptr = &str[0]; //Same as above line
N
I
.
E
V
S
Array indexing is same as dereferencing after

pointer addition.
S
.B
str[1] = a is same as *(str+1) = a
34
181
182
C-Style Strings
No string data type in C. Instead, a string is
interpreted as a null-terminated char array.
Null-terminated = last char is null char \0, not

explicitly written
char str[] = abc;
a
N
I
.
E
\0
V
S
String literals use S. Compiler converts literals

to char array.
.B
35
183
C-Style Strings
Char array can be larger than contained string

char str[5] = abc;
a
\0
Special chars start with \:

\n, \t, \b, \r: newline, tab, backspace, carriage
return
N
I
.
E
V
S
\\, \, \: backslash, apostrophe, quotation mark
S
.B
36
String functionalities
#include <string.h>
char pointer arguments: char str1[14]
char* strcpy(char* dest, const char* source);
strcpy(str1, hakuna );
N
I
.
strcat(str1, matata); //str1 now
has hakuna matata
E
V
S
S
B
.
More in documentation
W
W
W
char* strcat(char* dest, const char* source);
37
184
Today
Computer Memory
Pointers/Addresses
N
I
.
E
Arrays and Strings
V
S
S
Memory Allocation
.B
W
W
W
38
185
186
Dynamic Allocation
#include <stdlib.h>
sizeof (a C language keyword) returns number
of bytes of a data type.
malloc/realloc finds a specified amount of free
memory and returns a void pointer to it.
char * str = (char *) malloc( 3 * sizeof(char) );
N
I
.
E
strcpy(str, hi);
V
str = (char *) realloc( S
str , 6 * sizeof(char) );
S
.B
strcpy(str, hello);
W
W
W
39
Dynamic Deallocation
#include <stdlib.h>
free declares the memory pointed to by a
pointer variable as free for future use:
char * str = (char *) malloc( 3 * sizeof(char) );
N
I
.
E
strcpy(str, hi);
... use str ...
free(str);
V
S
S
.B
40
187
Dynamically Allocated Arrays

Allows you to avoid declaring array size at
declaration.
Use malloc to allocate memory for array when

needed:
int *dynamic_array;
N
I
.
dynamic_array = malloc( sizeof(
int ) * 10 );
E
V
Snow points to an array
dynamic_array[0]=1;S//
.B
W
W
W
41
188
Summary
Memory has stack and heap.
Pointers and addresses access memory.
Arrays are really chunks of memory. Strings are
null-terminated char arrays.
N
I
.
C allows user memory allocation.
Use malloc,
E
V
realloc and free.
S
S
.B
W
W
W
42
189
MIT OpenCourseWare
http://ocw.mit.edu

IAP 2013
N
I
.
E
V
S
S
.B
190
sort.c
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
// Sort an array A using insertion sort.
// Notice it is passed by reference.
void sort(int *A, int array_size) {
int cur_elem, insert_index;
for (int cur_index = 1; cur_index < array_size; cur_index++) {
cur_elem = *(A+cur_index);
insert_index = cur_index - 1;
// For each element in A, search for where it belong in the subarray
preceeding it's current location
while (insert_index >= 0 && cur_elem < *(A+insert_index)) {
*(A+insert_index+1) = *(A+insert_index);
insert_index -= 1;
}
*(A+insert_index+1) = cur_elem;
}
}
N
I
.
E
int main() {
// Allows us to generate random numbers
srand(time(NULL));
// Read a user input integer and store it in n
int n;
printf("Enter an integer n: ");
scanf("%d", &n);
V
S
S
.B
// An array named array. Change this to a dynamic array using malloc.

int *array = malloc(n * sizeof(int));
// Assign each element in the array a random number between 0 and 31,999
for (int i=0; i<n; i++) {
*(array+i) = rand() % 32000; // assigns random numbers
}
// Prints out the elements of the unsorted array

printf("The unsorted array is: ");
for (int x = 0; x < n; x++) {
printf("%d ", *(array+x));
}
printf("\n");
// Calls the sort function to sort the array
sort(array, n);
// Print out the elements of the now (supposedly) sorted array.
printf("The sorted array is: ");
for (int x = 0; x < n; x++) {
printf("%d ", *(array+x));
}
printf("\n");
free(array); //Making sure to free what I malloc!
191
return 0;
}
resize.c
#include <stdlib.h>
#include <stdio.h>
#include <time.h>
int main() {
// Allows you to generate random number
srand(time(NULL));
// Allows user to specify the original array size, stored in variable n1.
printf("Enter original array size: ");
int n1 = 0;
scanf("%d", &n1);
// Create a new array of n1 ints
int *a1 = malloc(n1 * sizeof(int));
N
I
.
E
for(int i = 0; i < n1; i++) {

// Set each value in a1 to 100
*(a1+i) = 100;
// Print each element out (to make sure things look right)
printf("%d ", *(a1+i));
V
S
S
.B
// User specifies the new array size, stored in variable n2.

printf("\nEnter new array size: ");
int n2 = 0;
scanf("%d", &n2);
// Dynamically change the array to size n2

a1 = realloc(a1, n2* sizeof(int)); // Resize the array
// If the new array is a larger size, set all new members to 0.

// Reason: dont want to use uninitialized variables.
if (n2 > n1) {

for(int j = n1; j<n2; j++) {
*(a1+j)=0;
}
}
for (int i = 0; i < n2; i++) {
//Print each element out (to make sure things look right)
printf("%d ", *(a1+i));
}
printf("\n");
// Done with array now, done with program :D
free(a1);
return 0;
}
192
MIT OpenCourseWare
http://ocw.mit.edu

IAP 2013
N
I
.
E
V
S
S
.B
193
194
6.s096
Introduction to C and C++
N
I
.
E
V
S
S
.B
Why?
N
I
.
E
V
S
S
.B
195
196
N
I
.
E
You.Bseek
performance
S
V
S
197
N
I
.
E
You.Bseek
performance
S
V
S
zero-overhead principle
198
N
I
You seek
to
interface
.
E
V
S
S
B
.
directly
with
hardware
W
W
199
N
I
.
E
That
s
kinda
it
S
.B
V
S
200
N
I
a nice way
to
avoid
writing
.
E
V
S
S
B
.
assembly
language
directly
W
W
W
C++
N
I
respondsVto
the
demands
of
.
E
S
S
B
.
maintaining
large
C
projects
W
W
W
201
202
C++11
N
I
respondsVto
the
demands
of
.
E
S
S
B
.
maintaining
large
C++
projects
W
W
W
N
I
Maintain power
and
flexibility
.
E
V
S
S
B
.
of
W what came before
W
W
203
204
Compilation
Pipeline
Today:
N
I
.
E
V
S
S
.B
205
Source Code
N
I
.
E
V
S
S
.B
Program
206
main.c
prog
int a = 1;
@*)!%
N
I
.
./prog
E
V
S
S
.B
gcc -o prog main.c
207
main.c
int a = 1;
main2.c .IN
E
V
S
S
int
b
=
2;
B
.
prog
@*)!%
./prog
gcc -o prog main.c main2.c
$ gcc -o prog main.c
N
I
$ ./prog
.
E
V
S
S
Hello,
.B World!
W
W
$ W
208
209
$ gcc -o prog main.c
N
I
$ ./prog
.
E
V
S
S
Hello,
.B World!
W
W
$ W
E
N
O
D
210
To debug the
sausage,
one
N
I
.
E
V
S
S
mustWsee
how
it
is
made.
B
.
W
Someone, probably
211
Main.java
Main.class
int a = 1;
%!(*@
N
I
.
E
V
S
S
.B
n
i
a
M
a
v
ja
212
Main.java
Main.class
int a = 1;
%!(*@
main.py
main.pyc
N
.I
E
V
S
S
a=1
.B
%!(*@
n
i
a
M
a
v
ja
m
n
o
h
t
py
y
p
.
ain
213
Main.java
Main.class
int a = 1;
%!(*@
main.py
main.pyc
N
.I
E
V
S
S
a=1
.B
n
i
a
M
a
v
ja
y
p
.
ain
%!(*@
m
n
o
h
t
py
main.c W
int a = 1;
int a = 1;
main.o
prog
%!(*@
@*)!%
g
o
r
./p
N
I
.
E
V
S
S
.B
214
N
I
.
E
V
S
S
.B
215
main.c
int a = 1;
216
int a = 1;
main.o
prog
%!(*@
@*)!%
Pre-Process E.IN
V
S
S
.B
Compile
Link
./prog
main.c
int a = 1;
217
int a = 1;
main.o
prog
%!(*@
@*)!%
main2.o
Pre-Process E.IN %!(*@
V
S
S
.B
Compile
Link
./prog
218
Pre-Process
N
I
.
E
V
S
S
.B
Compile
Link
219
Pre-Process
N
I
.
E
V
S
S
.B
Compile
Link
#include
#define
N
I
.
E
V
S
S
.B
#ifdef
220
rimshot.txt
ba-dum chh
joke.txt
N
I
.
E
A man walksVinto
S
S
a bar. Ouch!
.B
W "rimshot.txt"
#include
cpp -P joke.txt
221
output:
A man walks into
a bar. Ouch!
ba-dum chh
N
I
.
E
V
S
S
.B
cpp -P joke.txt
222
223
double.py
#define fosho def
#define kthx return
#define wutz print
These are called

macros
N
I
.
fosho double(x):
E
V
S
kthxBx
* 2
S
.
wutz double(6)
W
W
W
cpp -P double.py
output:
def double(x):
return x * 2
print double(6)
N
I
.
E
V
S
S
.B
cpp -P double.py
224
225
output:
def double(x):
return x * 2
print double(6)
cpp -P double.py | python
S
S
.B
12
AWE
S
N
I
.
E
OME
cpp -P double.py
beer.txt
#define beer(x) x bottles of \
beer on the wall...
beer(99)
N
I
.
beer(98)
E
V
beer(97)
BSS
.
...
cpp -P beer.txt
226
beer.txt
#define beer(x) x bottles of \
beer on the wall...
beer(99)
N
I
.
beer(98)
E
V
beer(97)
BSS
.
...
cpp -P beer.txt
227
output:
99 bottles of beer on the wall...
...
I
.
E
V
S
S
.B
cpp -P beer.txt
228
answer.txt
Whats 7 times 6?
#ifdef REVEAL
42
#endif
I
.
E
V
S
S
.B
cpp -P answer.txt
229
output:
Whats 7 times 6?
N
I
.
E
V
S
S
.B
cpp -P answer.txt
230
output:
Whats 7 times 6?
? ??
N
I
.
E
V
S
S
.B
cpp -P answer.txt
231
#define REVEAL
N
I
.
E
V
S
S
.B
cpp -P answer.txt
232
#define REVEAL
or:
N
I
.
E
cpp -P -D REVEAL
answer.txt
V
S
S
.B
cpp -P answer.txt
233
output:
Whats 7 times 6?
42
N
I
.
E
V
S
S
.B
cpp -P -D REVEAL answer.txt
234
answer.txt
Whats 7 times 6?
#ifndef REVEAL
42
#endif
I
.
E
V
S
S
.B
cpp -P answer.txt
235
(Fancy)
236
String Substitution
N
I
.
E
V
S
S
.B
237
How is this used in C?
N
I
.
E
V
S
S
.B
hello.c
#include <stdio.h>
int main() {
printf("Hello,
World!\n");
N
I
.
return 0;
E
V
S
}
S
B
gcc -E hello.c
238
hello.c
* angle brackets -> use the system search path
#include <stdio.h>
int main() {
printf("Hello,
World!\n");
N
I
.
return 0;
E
V
S
}
S
B
gcc -E hello.c
239
hello.c
* angle brackets -> use the system search path
#include <stdio.h>
int main() {
printf("Hello,
World!\n");
N
I
.
return 0;
E
V
S
}
S
B
gcc -E hello.c
240
output:
int printf(const char * , ...)
__attribute__((__format__
(__printf__, 1, 2)));
N
I
.
int main() {
E
V
S
printf("Hello,
World!\n");
S
B
.
}
W
W
W
* pretending printf is all thats defined in stdio.h
gcc -E hello.c
241
output:
int printf(const char * , ...);
int main() {
printf("Hello,
World!\n");
N
I
.
}
V
S
S
.B
* pretending printf is all thats defined in stdio.h
gcc -E hello.c
242
#include is not
N
I
.
E
V
S
import
pickle
S
.B
W
W
W
import java.io.*;
243
fib.c
#define MAX_FIB 20
int fib[MAX_FIB];
int main() {
fib[0] = 0;
N
I
.
fib[1] = 1;
E
V
S = 2; i < MAX_FIB; i++)
for(int Si
B
.
fib[i]
= fib[i-1] + fib[i-2];
W
W
return
0;
W
}
gcc -E fib.c
244
output:
int fib[20];
int main() {
fib[0] = 0;
fib[1] = 1;
IN
.
for(int iV=E 2; i < 20; i++)
S
S
fib[i]
=
fib[i-1]
+
fib[i-2];
B
.
W
}
gcc -E fib.c
245
debug.c
#include <stdio.h>
int main() {
#ifdef DEBUG
N
I
.
printf("Hello,
World!\n");
E
V
#endif
BSS
.
return
0;
W
W
}
W
gcc -DDEBUG debug.c -o debug
246
debug.c
#include <stdio.h>
int main() {
printf("Hello,
World!\n");
N
I
.
return 0;
E
V
S
}
S
B
gcc -DDEBUG debug.c -o debug
247
debug.c
#include <stdio.h>
int main() {
return 0;
N
I
.
}
V
S
S
.B
gcc debug.c -o debug
248
249
Pre-Process
N
I
.
E
V
S
S
.B
Compile
Link
main.c
int a = 1;
250
int a = 1;
main.o
prog
%!(*@
@*)!%
N
Compile
I
.
E
V
S
S
.B
./prog
N
Compile
I
.
E
V
S
S
.B
Type-checking
Linear processing
251
Type-checking
int reptile() {
return "frog";
N
}
I
.
E
V
S
S
.B
252
253
Type-checking
int reptile() {
return "frog";
N
}
I
.
E
V
S
S
reptile.c:
.B In function reptile:
W
reptile.c:2:5:
warning:
return
makes
W
W
integer
from pointer without a cast
Type-checking
def vegetable(day):
if day != "Tuesday":
return.IN"tomato"
E
else:
SV
S
1000
B
.return
254
255
Type-checking
def vegetable(day):
if day != "Tuesday":
return.IN"tomato"
E
else:
SV
S
1000
B
.return
Python says: no problem
int reptile() {
return "frog";
N
}
I
.
E
V
S
S
.B
256
int () {
return char*;
N
}
I
.
E
V
S
S
.B
257
258
int vegetable(char *day) {
if (strcmp(day, "Tuesday") != 0){
N
return "tomato";
I
.
E
} else {
SV
S
return
.B 1000;
W
}
W
}
W
int (char*) {
if (int){
N
return char*;
I
.
E
} else {
SV
S
return
.B int;
W
}
W
}
W
259
int (char*) {
if (int){
N
return char*;
I
.
E
} else {
SV
S
return
.B int;
W
}
W
}
W
260
int (char*) {
if (int){
N
return char*;
I
.
E
} else { SV
S
return
.B int;
W
} W
} W
261
N
Everything
has
I
.
E
V
S
S
.B
W
a single,
fixed
type
W
W
262
def foo(a, b):
return
a
+
b
IN
.
E
V
S
S
.B
W
foo(2,
3)
W
W
foo("2", "3")
263
Variable Declarations
int foo;
float foo;
double foo; .IN
E
char foo; SV
S
.B
W
int foo[42];
W
int *foo;
struct Bar foo;
264
Function Declarations
double fmin(double, double);
return type.BS
N
I
.
E
V
S argument types
265
Function Declarations
void exit(int);
N
I
.
E
V
returns nothing
S
S
.B
intWrand(void);
takes no arguments
266
267
int foo(int
a,
int
b){
N
I
.
E
V
return
a
+
b;
S
S
.B
}
WW
W
reptile.c: In function
reptile:
N
I
.
E
reptile.c:2:5:
warning:
return
makes
V
S
S
integer from
.B pointer without a cast
268
reptile.c: In function
reptile:
N
I
.
E
reptile.c:2:5:
warning:
return
makes
V
S
S
integer from
.B pointer without a cast
int a = 4;
float b = (float)a;
269
int
float
double
N
I
.
char
E
V
S
S
int[] W.B
W
int*W
void (*f )(int)
struct X
all theoretical casts
270
int
float
double
char
int[]
int*
void (*f )(int)
struct X
int
float
double
N
I
.
char
E
V
S
S
int[] W.B
W
int*W
void (*f )(int)
struct X
allowed casts
271
int
float
double
char
int[]
int*
void (*f )(int)
struct X
N
I
.
E
V
S
S
.B
272
int
float
double
N
I
.
char
E
V
S
S
int[] W.B
W
int*W
void (*f )(int)
struct X
allowed casts
273
int
float
double
char
int[]
int*
void (*f )(int)
struct X
int
float
double
N
I
.
char
E
V
S
S
int[] W.B
W
int*W
void (*f )(int)
struct X
allowed casts
274
int
float
double
char
int[]
int*
void (*f )(int)
struct X
int
float
double
N
I
.
char
E
V
S
S
int[] W.B
W
int*W
void (*f )(int)
struct X
implicit casts
275
int
float
double
char
int[]
int*
void (*f )(int)
struct X
int
float
double
N
I
.
char
E
V
S
S
int[] W.B
W
int*W
void (*f )(int)
struct X
implicit casts
276
int
float
double
char
int[]
int*
void (*f )(int)
struct X
int
float
double
N
I
.
char
E
V
S
S
int[] W.B
W
int*W
void (*f )(int)
struct X
implicit casts
277
int
float
double
char
int[]
int*
void (*f )(int)
struct X
int
float
double
N
I
.
char
E
V
S
S
int[] W.B
W
int*W
void (*f )(int)
struct X
implicit casts
278
int
float
double
char
int[]
int*
void (*f )(int)
struct X
N
Compile
I
.
E
V
S
S
.B
Type-checking
Linear processing
279
N
I
.
E
V
S
S
.B
Linear processing
( just a small note)

280
You can only use

whats declared above
N
I
.
E
V
S
S
.B
281
int main() {
printf("%d\n", answer());
return 0;
N
I
.
}
V
S
S
.B
int answer()
{
W
W
return
1337;
W
}
282
int main() {
return 0;
N
I
.
}
E
V
S
S
.B
int answer()
{
W
W
return
1337;
W
}
283
int answer() {
return 1337;
N
I
.
E
V
int main()SS{
B
.
printf("%d\n",
answer());
W
W
return
0;
W
}
284
285
int answer();
declaration
int main() {
N
I
.
printf("%d\n",
answer());
E
V
returnSS0;
B
.
}
int answer() {
return 1337;
definition
HMM
N
I
.
E
V
S
S
.B
286
287
int answer();
declaration
int main() {
N
I
.
printf("%d\n",
answer());
E
V
returnSS0;
B
.
}
int answer() {
return 1337;
definition
288
int answer();
declaration
int main() {
N
I
.
printf("%d\n",
answer());
E
V
returnSS0;
B
.
}
W
int answer() {
return 1337;
}
definition
289
int answer();
declaration
#include "answer.h"
int main() {
N
I
.
printf("%d\n",
answer());
E
V
returnSS0;
B
.
}
W
int answer() {
return 1337;
}
definition
290
Pre-Process
N
I
.
E
V
S
S
.B
Compile
Link
291
main.o
N
I
int main() VE.
S
S
.B
W
intWanswer()
W
main.o
N
I
int main() VE.
S
S
.B
W
W
W
292
293
answer.c: In function main:
answer.c:4: warning: implicit declaration of
function answer
N
I
. architecture x86_64:
Undefined symbols E
for
V
"_answer", referenced
from:
S
S
_main in
.B ccuzmRrm.o
W not found for architecture x86_64
ld: symbol(s)
W
collect2:
W ld returned 1 exit status
294
function answer
N
I
Undefined symbols E
for
V
from:
S
S
_main in
.B ccuzmRrm.o
ld: symbol(s)
W
collect2:
295
function answer
N
I
Undefined symbols E
for
V
from:
S
S
_main in
.B ccuzmRrm.o
ld: symbol(s)
W
collect2:
Compiler: I dont know what answer is.

Ill assume it returns an int.
296
function answer
N
I
Undefined symbols E
for
V
from:
S
S
_main in
.B ccuzmRrm.o
ld: symbol(s)
W
collect2:
297
function answer
N
I
Undefined symbols E
for
V
from:
S
S
_main in
.B ccuzmRrm.o
ld: symbol(s)
W
collect2:
Linker: I looked in all the object files,

but I couldnt find answer.
main.o
N
I
int main() VE.
S
S
.B
W
W
W
298
299
main.o
N
I
int main() VE.
S
S
.B
W
W
W
answer.o
int answer()
300
main.o
N
I
int main() VE.
S
S
.B
W
W
W
int main() {
return 0;
}
answer.o
int answer()
int answer() {
return 1337;
}
301
main.o
N
I
int main() VE.
S
S
.B
W
W
W
answer.o
int answer()
302
prog
N
I
.
int
E main()
V
S
S
.B
int answer()
gcc -o prog main.c answer.c

answer.c: In function
main:
N
I
.
E
answer.c:4: warning:
implicit declaration of
V
S
function answer
.B
303
answer.c: In function
main:
N
I
.
E
answer.c:4: warning:
implicit declaration of
V
S
function answer
.B
Compiler: I dont know what answer is.

Ill assume it returns an int.
304
answer.h
int answer();
main.c
N
#include "answer.h"
I
.
E
V
S
S
.B {
int main()
W
printf("%d\n",
answer());
W
Wreturn 0;
305
answer.h
int answer();
answer.c
N
#include "answer.h"
I
.
E
V
S
S
.B
int answer()
{
W
return
1337;
W
W
}
306
307
Summary
N
I
.
E
V
S
S
.B
answer.h
int answer();
main.c
N
#include "answer.h"
I
.
E
V
S
S
.B {
int main()
W
printf("%d\n",
answer());
W
Wreturn 0;
308
Preprocess:
gcc -E main.c
int answer();
N
I
int main() {
E.
V
S
printf("%d\n",
answer());
S
B
.
return
W 0;
}
WW
309
Compile:
gcc -c main.c main.c
main.o
%!(*@
N
I
.
E
answer.o
V
S
S
.B
%!(*@
W
310
Link:
311
gcc -o prog main.o main.o
prog
%!(*@
N
I
.
E
V
S
S
.B
312
Pre-Process
N
I
.
E
V
S
S
.B
Compile
Link
MIT OpenCourseWare
http://ocw.mit.edu

IAP 2013
N
I
.
E
V
S
S
.B
313
The assignment was split into 2 problems, but below we've included only the final
versions of all the files.
The header files remained unchanged.
N
I
.
E
FIBONACCI.C
#include <stdio.h>
#include "fibonacci.h"
void print_fib(int n) {
printf("%d\n", fib(n));
}
int fib(int n) {
if (n <= 0) {
return
} else if(n ==
return
} else {
return
}
}
V
S
S
.B
0;
1) {
1;
fib(n-1) + fib(n-2);
REVERSE.C
#include <stdio.h>
void reverse(char *str, int len) {
char reversed[len+1];
int pos = 0;
int caret = len;
reversed[len] = '\0';
for (int i = len - 1; i >= -1; --i){
314
if (i == -1 || str[i] == ' '){
for (int j = i + 1; j < caret; ++j){
reversed[pos++] = str[j];
}
if (i != -1) {
reversed[pos++] = ' ';
}
caret = i;
}
printf("%s\n", reversed);
FIBEVERSE.C
#include
#include
#include
#include
<stdlib.h>
<string.h>
"fibonacci.h"
"reverse.h"
N
I
.
E
int main(int argc, char *argv[]) {

int i = 1;
V
S
#ifdef FIBONACCI
if (i < argc) {
print_fib(atoi(argv[i]));
i++;
}
#endif
S
.B
#ifdef REVERSE
if (i < argc) {
reverse(argv[i], strlen(argv[i]));
i++;
}
#endif
return 0;
}
315
MIT OpenCourseWare
http://ocw.mit.edu

IAP 2013
N
I
.
E
V
S
S
.B
316

C Program Notes

Diunggah oleh

Informasi Dokumen

Judul Asli

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

C Program Notes

Diunggah oleh

Hak Cipta:

Format Tersedia

www.onlineeducation.bharatsevaksamaj.

www.bsscommunitycollege.in www.bssnewgeneration.in www.bsslifeskillscollege.in

www.bsscommunitycollege.in www.bssnewgeneration.in www.bsslifeskillscollege.in

www.bsscommunitycollege.in www.bssnewgeneration.in www.bsslifeskillscollege.in

www.bsscommunitycollege.in www.bssnewgeneration.in www.bsslifeskillscollege.in

BufferW*buf = new Buffer(128);

www.bsscommunitycollege.in www.bssnewgeneration.in www.bsslifeskillscollege.in

W *fbuf = new FBuffer(128);

www.bsscommunitycollege.in www.bssnewgeneration.in www.bsslifeskillscollege.in

www.bsscommunitycollege.in www.bssnewgeneration.in www.bsslifeskillscollege.in

www.bsscommunitycollege.in www.bssnewgeneration.in www.bsslifeskillscollege.in

BufferW*fbuf = new FBuffer(128);

// only ~Buffer is called

www.bsscommunitycollege.in www.bssnewgeneration.in www.bsslifeskillscollege.in

BufferW*fbuf = new FBuffer;

www.bsscommunitycollege.in www.bssnewgeneration.in www.bsslifeskillscollege.in

www.bsscommunitycollege.in www.bssnewgeneration.in www.bsslifeskillscollege.in

char *buf = (char *)malloc(128);

www.bsscommunitycollege.in www.bssnewgeneration.in www.bsslifeskillscollege.in

// C-style cat casts

class Tiger : public Cat { };

class Persian : public Cat { };

Cat *c = new Persian;

www.bsscommunitycollege.in www.bssnewgeneration.in www.bsslifeskillscollege.in

Tiger *t = new Tiger;

Cat *c2 = static_cast<Cat

www.bsscommunitycollege.in www.bssnewgeneration.in www.bsslifeskillscollege.in

// almost valid down-cast

Cat *c = new Tiger;

Tiger *t1 = (Tiger *)c;

Tiger *t2 = static_cast<Tiger

www.bsscommunitycollege.in www.bssnewgeneration.in www.bsslifeskillscollege.in

class Cat { virtual void purr() { } };

class Tiger : public Cat { };

class Persian : public Cat { };

www.bsscommunitycollege.in www.bssnewgeneration.in www.bsslifeskillscollege.in

Tiger *t1 = (Tiger *)c;

Tiger *t2 = static_cast<Tiger

www.bsscommunitycollege.in www.bssnewgeneration.in www.bsslifeskillscollege.in

www.bsscommunitycollege.in www.bssnewgeneration.in www.bsslifeskillscollege.in

void swap(int *a, int *b) {

www.bsscommunitycollege.in www.bssnewgeneration.in www.bsslifeskillscollege.in

void swap(int &a, int &b) {

www.bsscommunitycollege.in www.bssnewgeneration.in www.bsslifeskillscollege.in

www.bsscommunitycollege.in www.bssnewgeneration.in www.bsslifeskillscollege.in

www.bsscommunitycollege.in www.bssnewgeneration.in www.bsslifeskillscollege.in

www.bsscommunitycollege.in www.bssnewgeneration.in www.bsslifeskillscollege.in

www.bsscommunitycollege.in www.bssnewgeneration.in www.bsslifeskillscollege.in

SNDFILE *open(const char *);

www.bsscommunitycollege.in www.bssnewgeneration.in www.bsslifeskillscollege.in

SNDFILE *sf_open(const char *);

www.bsscommunitycollege.in www.bssnewgeneration.in www.bsslifeskillscollege.in

www.bsscommunitycollege.in www.bssnewgeneration.in www.bsslifeskillscollege.in

www.bsscommunitycollege.in www.bssnewgeneration.in www.bsslifeskillscollege.in

std::cout << "Hello, World!"

www.bsscommunitycollege.in www.bssnewgeneration.in www.bsslifeskillscollege.in

www.bsscommunitycollege.in www.bssnewgeneration.in www.bsslifeskillscollege.in

www.bsscommunitycollege.in www.bssnewgeneration.in www.bsslifeskillscollege.in

www.bsscommunitycollege.in www.bssnewgeneration.in www.bsslifeskillscollege.in

www.bsscommunitycollege.in www.bssnewgeneration.in www.bsslifeskillscollege.in

www.bsscommunitycollege.in www.bssnewgeneration.in www.bsslifeskillscollege.in

www.bsscommunitycollege.in www.bssnewgeneration.in www.bsslifeskillscollege.in

www.bsscommunitycollege.in www.bssnewgeneration.in www.bsslifeskillscollege.in

char buf = (char )malloc(128);

Tiger t1 = (Tiger )c;

Tiger t1 = (Tiger )c;

void swap(int a, int b) {

SNDFILE open(const char );

SNDFILE sf_open(const char );