c++ primer 第十九章习题

#include <iostream>  
#include <cstdlib>  
  
void *operator new(std::size_t n){  
    std::cout << "my new"<<endl;  
    if (void *mem = malloc(n))  
        return mem;  
    else  
        throw std::bad_alloc();  
}  
void operator delete(void *mem) noexcept{  
    std::cout << "my delete"<<endl;  
    free(mem);  
}  
int main()  
{  
    using namespace std;  
    int *a = new int(486);  
    cout << a << " " << *a << endl;  
    delete a;  
    return 0;  
}  

练习19.3 (a T (b F 因为pb实际指向的对象是C的基类无法转换 (c T

练习19.4

try {
C& pc = dynamic_cast<C&>(*pa);
//
}
catch(bad_cast) {
}

练习19.5 当不能够使用虚函数完成又需要用基类指针或引用调用派生类成员的时候。

练习19.10 (a A* (b A& (c B&

练习19.11 区别在于指向数据成员的指针没有指定对象，调用符号不同，需要考虑访问权限。

练习19.12 const Screen::pos Screen::*pdata = &Screen::cursor;

练习19.13 const std::string Sales_data::*pdata = &Sales_data::bookNo;

练习19.14 合法

练习19.15 调用的符号，需要考虑类内权限，函数与指针不会自动转换。

练习19.16 using avg = (double)(Sales_data::*)() const;

练习19.18 count_if(vec.begin(),vec.end(),mem_fn(&string::empty));

练习19.19

vector<Sales_data>::iterator largerThanD(vector<Sales_data>& vec, double d) {
double d = 0;
auto fn = mem_fn(&Sales_data::avg);
return find_if(vec.begin(),vec.end(),[&](string&s){return fn(s) > d;}
}

练习19.21-25

#ifndef TOKEN_H
#define TOKEN_H
#include<iostream>
#include<string>
#include "Sales_data.h"
using std::string;

class Token
{
	friend std::ostream &operator<<(std::ostream &os, const Token &t);
public:
	Token():tok(INT),ival(0){}
	Token(const Token& t):tok(t.tok){copyUnion(t);}
	Token(Token&& t):tok(std::move(t.tok)){copyUnion(std::move(t));}
	Token& operator=(Token&& t);
	Token& operator=(const Token& t);
	~Token(){if(tok == STR) sval.~string();}
	Token& operator=(const string&);
	Token& operator=(const Sales_data&);
	Token& operator=(char);
	Token& operator=(int);
	Token& operator=(double);
private:
	union {
		char cval;
		int ival;
		double dval;
		string sval;
		Sales_data sdval;
	};
	enum {INT, CHAR, DBL, STR,SDA} tok;
	void copyUnion(const Token& );
	void copyUnion(Token&&);
};

inline void Token::copyUnion(const Token& t) {
	switch(t.tok) {
		case Token::INT: ival = t.ival;break;
		case Token::CHAR: cval = t.cval;break;
		case Token::DBL: dval = t.dval;break;
		case Token::STR: new(&sval) string(t.sval);break;
		case Token::SDA: new(&sdval) Sales_data(t.sdval); break;
	}
}

inline void Token::copyUnion(Token&& t) {
	switch(t.tok) {
		case Token::INT: ival = std::move(t.ival);break;
		case Token::CHAR: cval = std::move(t.cval);break;
		case Token::DBL: dval = std::move(t.dval);break;
		case Token::STR: new(&sval) string(std::move(t.sval));break;
		case Token::SDA: new(&sdval) Sales_data(std::move(t.sdval)); break;
	}
}

Token& Token::operator=(Token&& t){
	if(tok == STR)
		if (t.tok == STR){
			sval = std::move(t.sval);
			return *this;
		}
		else
			sval.~string();
	if(tok == SDA)
		if(t.tok == SDA){
			sdval = std::move(t.sdval);
			return *this;
		}
		else
			sdval.~Sales_data();
	tok = std::move(t.tok);
	copyUnion(std::move(t));

	return *this;
}

Token& Token::operator=(const Token& t){
	if(tok == STR)
		if (t.tok == STR){
			sval = t.sval;
			return *this;
		}
		else
			sval.~string();
	if(tok == SDA)
		if(t.tok == SDA){
			sdval = t.sdval;
			return *this;
		}
		else
			sdval.~Sales_data();
	tok = t.tok;
	copyUnion(t);
	return *this;
}

Token& Token::operator=(const string& s){
	if( tok == STR) {
		sval = s;
	}else {
	    if(tok == SDA) 
		    sdval.~Sales_data();
		new(&sval) string(s);
		tok = STR;
	}
	return *this;
}
Token& Token::operator=(const Sales_data& sa){
	if( tok == SDA) {
		sdval = sa;
	}else {
		if(tok == STR)
		    sval.~string();
		new(&sdval) Sales_data(sa);
		tok = SDA;
	}
	return *this;
}
Token& Token::operator=(char c) {
	if(tok == STR) sval.~string();
	if(tok == SDA) sdval.~Sales_data();
	cval = c;
	tok = CHAR;
	return *this;
}
Token& Token::operator=(int i) {
	if (tok == STR) sval.~string();
	if(tok == SDA) sdval.~Sales_data();
	ival = i;
	tok = INT;
	return *this;
}
Token& Token::operator=(double d) {
	if (tok == STR) sval.~string();
	if(tok == SDA) sdval.~Sales_data();
	dval = d;
	tok = DBL;
	return *this;
}

std::ostream& operator<<(std::ostream &os, const Token &t) {  
    switch (t.tok) {  
    case Token::INT: os << t.ival; break;  
    case Token::CHAR: os << t.cval; break;  
    case Token::DBL: os << t.dval; break;  
    case Token::STR: os << t.sval; break;  
    case Token::SDA: os << t.sdval; break;  
    }  
    return os;  
}