~cpp 
string Core::name() const { return n; }

double Core::grade() const {
	return ::grade(midterm. final, homework);
}

istream& Core::read_common(istream& in) {
	in>>n>>midterm>>final;
	return in;
}

istream& Core::read(istream& in) {
	read_common(in);
	read_hw(in, homework);
	return in;
}
 

~cpp 
istream& Grad::read(istream& in) {
	read_common(in);
	in >> thesis;
	read_hw(in, homework);
	return in;
}
 

~cpp 
istream& Grad::read(istream& in) {
	Core::read_common(in);
	in >> thesis;	// thesis는 Core가 아니라 Grad의 멤버 변수이므로 범위 지정 연산자를 사용해서는 안된다.
	Core::read_hw(in, Core::homework);
	return in;
}
 

~cpp 
double Grad::grade() const {
	return min(Core::grade(), thesis);		// min()은 <algorithm>에 정의된 함수이다.
}
 

~cpp 
class Core {
public:
	Core():midterm(0), final(0) {}
	Core(std::istream& is) { read(is); }
};

class Grad:public Core {
public:
	Grad():thesis(0) {}
	Grad(std::istream& is) { read(is); }
};
 

~cpp 
bool compare_grades(Core c1, Core c2) {
	return c1.grade() < c2.grade();
}
 

~cpp 
#ifndef GUARD_Core_h
#define GUARD_Core_h

#include <iostream>
#include <stdexcept>
#include <string>
#include <vector>

class Core {
public:
	Core(): midterm(0), final(0) { }
	Core(std::istream& is) { read(is); }

	std::string name() const;

	// as defined in 13.1.2/230
	virtual std::istream& read(std::istream&);		// virtual 키워드로 정의된 함수는 반드시 재정의되어야한다.
	virtual double grade() const;

protected:
	// accessible to derived classes
	std::istream& read_common(std::istream&);
	double midterm, final;
	std::vector<double> homework;

private:
	// accessible only to `Core'
	std::string n;
};

class Grad: public Core {
public:
	Grad(): thesis(0) { }
	Grad(std::istream& is) { read(is); }

	// as defined in 13.1.2/230; Note: `grade' and `read' are `virtual' by inheritance
	double grade() const;
	std::istream& read(std::istream&);
private:
	double thesis;
};

bool compare(const Core&, const Core&);
#endif
 

~cpp 
class Core {
public:
	virtual ~Core() { }
	//이전과 동일
};
 

~cpp 
istream& Student_info::read(istream& is) {
	delete cp;		// 언어적으로 널포인터를 해제하는 것은 문제가 없으므로 체크하는 코드를 넣지 않아도 된다.
	char ch;
	is>>ch;

	if(ch == 'U') {
		cp = new Core(is);
	} else {
		cp = new Grad(is);
	}

	return is;
}
 

~cpp 
class Core {
	friend class Student_info;
protected:
	virtual Core* clone() const { return new Core(*this); }
};

class Grad {
protected:
	Grad* clone() const { return new Grad(*this); }		// 본래 virtual 함수에서는 기본클래스와 파생클래스에서
								// 오버로드한느 함수의 파라메터 명세, 리턴형이 동일해야하지만
								// 포인터형인 경우에는 파생 클래스의 포인터를 사용하는 것이 가능하다.
};
 

~cpp 
Student_info::Student_info(const Student_info& s) : cp(0) {
	if (s.cp) cp = s.cp->clone();
}

Student_info& Student_info::operator=(const Student_info& s) {
	if (&s != this) {
		delete cp;
		if (s.cp)
			cp = s.cp->clone();
		else
			cp = 0;
	{
	return *this;
}
 

~cpp 
 //만약 r이 Core의 객체이고 Core::regrade(double)는 인자로 받은 것을 final에 기록한다.  
 //Grad::regrade(double, double) 인자로 받은값으로 final, thesis를 할당
 r.regrade(100);		// 작동
 r.regrade(100, 100);	// 컴파일 오류
 

~cpp 
 //만약 r이 Grad의 객체이고 Core::regrade(double)는 인자로 받은 것을 final에 기록한다.  
 //Grad::regrade(double, double) 인자로 받은값으로 final, thesis를 할당
 r.regrade(100);		// 컴파일 오류. Grad::compare 를 기대하기 때문에 이런 문제가 발생한다. 
 r.Core::regrade(100);	// 작동. 범위 연산자를 이용해서 명시적으로 호출하는 것은 허용한다.
 r.regrade(100, 100);	// 작동.
 

~cpp 
 virtual void Core::regrade(double d, double =0) { final = d; }