浙江大学c++讲义

Object-Oriented Programming

1.Abstraction（数据抽象）

Encapsulation(hidden implementation)封装性

Object

State,Data,

Message, Method, Interface, Operation,Function Type:

All objects of a particular type can receive the same messages.

2.Inheritance（继承性）

3.Polymorphism（多态性）

4.A Better C

4.1 // comments

/* */

//

4.2 Function Prototype

void *malloc(size_t);

4.3 The new & delete Operators char *p = new char[3];

int *p = new int[3];

4.4 Defining variables anywhere

int k;

k = 5;

int m;

m = k+6;

4.5 Reference

int k = 8;

int &m = k;

4.6 Inline function

4.7 const

5.Object Oriented Programming 5.1 Abstraction

Encapsulation(hidden implementation) object & class

struct A

{

int k;

float b;

int GetK(){

return k;

}

};

A a;

a.k = 555;

class A

{

private:

int k; //hidden implementation

float b;

public:

void SetK(int k){ //member function k = k;

}

};

A a;

a.k = 777; //. X

a.GetK()

constructor (initialization)

destructor(cleanup)

class Stack

{

};

5.2 Inheritance

class Basic

{

};

class Derive1 : public Basic

{

};

5.3 Polymorphism

（多态性）

5.3.1Static Polymorphism

Overloading

5.3.1.1 function Overloading(函数重载) 5.3.1.2 operator Overloading(操作符重载) class Complex

{

double m_r;

double m_i;

Complex(double r=0.0,double i=0.0)

{

m_r=r;

m_i=i;

}

void operator()(double r,double i)

{

m_r=r;

m_i=i;

}

Complex operator+(const Complex &c)const

{

return Complex(m_r+c,m_r, m_i+c,m_i);

}

double GetR() const

{

retur m_r;

}

double GetI() const

{

retur m_i;

}

}

class ComplexPtr

{

Complex *m_ptr;

public:

ComplexPtr(Complex &c)

{

m_ptr=c;

}

const ComplexPtr & operator=(Complex * const ptr) {

m_ptr=ptr;

return *this;

}

Complex * operator->()const

{

return m_ptr;

}

Complex & operator *()

{

return *m_ptr;

}

Complex &operator[] (int i)

{

return m_ptr[i];

}

const Complex &operator[] (int i) const

{

return m_ptr[i];

}

ComplexPtr &operator++()

{

m_ptr++;

return *this;

}

ComplexPtr &operator++(int)

{

m_ptr++;

return *this;

}

}

void main()

{

Complex c(3,4);

ComplexPtr ptr(c);

cout<GetR()<

cout<<(*ptr).GetR()<

ptr=new Complex[10];

ptr[1](5.6);

ptr[2]=ptr[1]+c;

++ptr;

ptr++;

}

●Default Arguments(默认参数)

5.3.1.3 Redefining(重定义)

●name hiding

●Overriding(重写，覆盖，超载，过载)

5.3.2Dynamic polymorphism

●Upcasting（向上类型转换）

●Virtual Function

●Incremental development（增量式开发）

6.File & Stream

6.1 Text file

cout << 123.567 << endl;

k = 123 ;

cout ? k ;

cout.fill('$');

cout.precision(8);

cout.width(7);

cout.setf(ios::hex);

cout << 23 << endl;

fstream in("in.txt",ios::in);

fstream out("out.txt",ios::out);

if (!in)

return;

while (!in.eof())

{

char ch = in.get();

out.put(ch);

}

6.2 Binary file

read

write

7.Templates

7.1 Function templates

template

T Max(T x,T y)

{

return (x>y?x : y);

}

7.2 Class templates

#include

const int STACKSIZE = 50; template

class Stack

{

T *m_pItem;

int m_top;

int m_size;

public:

Stack(int size = STACKSIZE){

m_size = size;

m_pItem = new int[size];

m_top = -1;

}

void Push(T item){

m_pItem[++m_top] = item;

}

T Pop();

};

template

T Stack::Pop()

{

return m_pItem[m_top--];

}

void main()

{

Stack s(10);

int i;

for (i=0;i<10;i++){

s.Push(i);

}

for (i=0;i<10;i++)

cout << s.Pop() << endl;

}

}

8.Exception handling

8.1 assert

8.2 return true/false

8.3 try/catch throw

#include

class Overflow{};

class Underflow{};

const int STACKSIZE = 50; template

class Stack

{

T *m_pItem;

int m_top;

int m_size;

public:

Stack(int size = STACKSIZE){

m_size = size;

m_pItem = new int[size];

m_top = -1;

}

void Push(T item){

if (m_top >= m_size-1)

throw Overflow();

m_pItem[++m_top] = item;

}

T Pop();

};

template

T Stack::Pop()

{

if (m_top < 0)

throw Underflow();

return m_pItem[m_top--];

}

void main()

{

Stack s(3);

int i;

try

{

for (i=0;i<10;i++){

s.Push(i);

}

}

catch(Overflow obj){

cout << "Stack Overflow" << endl;

}

try

{

for (i=0;i<10;i++)

cout << s.Pop() << endl;

}

catch(Underflow){

cout << "Stack Underflow" << endl;

}

}

global data area

stack

heap

9.Copy-constructor

T(const T &)

overloading =

overloading T(const &T) class String

{

char *p;

int l;

public:

String(char * s=null)

{

if(s)

{

l=::strlen(s);

p=new char[l+1];

::strcpy(p,s)

}

else

{

p=null;

l=0;

}

}

String (const String &s)

{

if(s.p)

{

l=::strlen(s.p);

p=new char[l+1];

::strcpy(p,s.p)

}

else

{

p=null;

l=0;

}

}

~String()

{

delete[] p;

}

}

String s1(“Hi”);

String s2=s1;

（虚析构函数与纯虚函数）

Abstract base classes（抽象基类）

class Base

{

int *p;

public:

Base(int size)

{

p=new int[size];

}

~Base()

{

delete []p;

}

};

class Derive:public Base

char * s;

public:

Derive(int size):Base(size)

{

s=new char[size];

}

~Derive()

{

s=new char[size];

}

}

Base *pB=new Derive(10);

delete pB;

11.Run-time type identification (RTTI)

typeid(t).name()

#include

class Base

{

};

class Derive:public Base

{

};

void main()

{

Base *bp=new Derive;

cout<

}

12.C++ explicit casts

dynamic_cast<> downcasting

static_cast<> upcasting

reinterpret_cast<>

const_cast

Base b;

Derive d;

Base *bp;

Derive *dp;

bp=dynamic_cast(&d);

bp=&b;

dp=dynamic_cast(bp);

bp=*d;

dp= dynamic_cast(bp);

Derive &dr1=dynamic_cast(*bp); Derive &dr2=dynamic_cast(b);

13.How C++ implements late binding VTABLE VPTR

14.Static members

class A

{

static int m;

int n;

};

A a1,a2;

A1.m=7;

A* ap=new A;

cout<m<<”,”;

ap->m+=12;

cout<m<<”,”; delete apl

cout<

https://www.360docs.net/doc/df12354682.html,space

namespace A

{

int m;

namespace B

{

int m;

int n;

void Fb()

{

m=3;

n=4;

}

}

void Fa()

{

B::m+=7;

m=23;

}

}

namespace B

{

int m;

}

int m;

void F()

{

m=8;

A::m=9;

B::m=10;

A::B::m=10;

}

16.Pointer to class member

17.Multiple inheritance

class Base1

{

int i;

}

class Base2

{

int i;

}

class Derive:public Base1,public Base2 {

float f;

int getInt()

{

return i;

}

float getFloat()

{

return f;

}

}