动态绑定
#include <iostream>
#include <string>
class Animal {
public:
virtual ~Animal() { }
virtual void say() = 0;
virtual void Print() = 0;
};
class Cat : public Animal {
public:
Cat(const std::string& str): name(str) { }
virtual void say() {
std::cout << name << " miaomiao~~ " << std::endl;
}
virtual void Print() {
std::cout << " Cat Print" << std::endl;
}
private:
std::string name;
};
class Dog : public Animal {
public:
Dog(const std::string& str) : name(str) { }
virtual void say() {
std::cout << name << " wangwang~~ " << std::endl;
}
virtual void Print() {
std::cout << " Dog Print" << std::endl;
}
private:
std::string name;
};
void test21() {
Cat cat("cat");
Dog dog("dog");
Animal* pcat = &cat;
Animal* pdog = &dog;
std::cout << "L01: ";
pcat->say();
std::cout << "L02: ";
pdog->say();
std::cout << "L03: ";
cat.say();
std::cout << "L04: ";
dog.say();
void* tmp = ((void**)pcat)[0];
((void**)pcat)[0] = ((void**)pdog)[0];
((void**)pdog)[0] = tmp;
std::cout << "L05: ";
pcat->say();
pcat->Print();
std::cout << "L06: ";
pdog->say();
pdog->Print();
std::cout << "L07: ";
cat.say();
std::cout << "L08: ";
dog.say();
}
int main() {
test21();
return 0;
}
const 重载
const修饰类成员函数,该成员函数里面不可能修改成员变量
其中const也算函数签名的一部分, 只用于在类的成员函数
const的重载使用条件:如果一个类声明中有const重载的函数,const对象使用const修饰的成员函数,非const对象使用没有const修饰的成员函数
#include <iostream>
using namespace std;
class Foo
{
public:
void Print() const{
cout << "Foo::Print const" << endl;
}
void Print(){
cout << "Foo::Print" << endl;
}
};
int main(int argc, char *argv[])
{
const Foo fConst;
fConst.Print();
Foo f;
f.Print();
return 0;
}
重载new delete
new ----> operator new 分配空间
调用相应的构造函数
delete ---- > 调用析构函数
operator delete
#include <iostream>
#include <string>
using namespace std;
class Foo
{
private:
int _id;
long _data;
string _str;
public:
Foo():_id(0)
{
cout << "default ctor. this=" << this << " id="<<_id << endl;
}
Foo(int i): _id(i)
{
cout << "ctor.this=" << this << " id=" << _id << endl;
}
~Foo()
{
cout << "dtor.this=" <<this << " id=" << _id <<endl;
}
static void *operator new(size_t size);
static void operator delete(void* pdead, size_t size);
static void *operator new[](size_t size);
static void operator delete[] (void*pdead, size_t size);
};
void * Foo::operator new(size_t size)
{
cout << " Foo::operator new " << endl;
Foo *p = (Foo*)malloc(size);
return p;
}
void Foo::operator delete(void* pdead, size_t size)
{
cout << " Foo::operator delete " << endl;
free(pdead);
}
void * Foo::operator new[](size_t size)
{
Foo* p = (Foo*)malloc(size);
return p;
}
void Foo::operator delete[](void*pdead, size_t size)
{
free(pdead);
}
int main(int argc, char *argv[])
{
Foo *pf = new Foo;
delete pf;
cout << "-----------------" <<endl;
Foo *p = ::new Foo;
::delete p;
return 0;
}
重载new() delete()
我们可以重载类的成员函数operator new(), 写出多个版本,前提是每个版本的声明必须有独特的参数列,其中第一个参数必须是size_t, 其余参数指定的placement arguments为初值
Foo* pf = new (300, 'c')Foo;
我们也可以重载类的成员函数operator delete(),写出多个版本,但是他们绝不会被delete调用。只有当new所调用的析构函数抛出exception,才会调用这些重载版的operator delete(). 它只可能这样被调用,主要用来归还未能完全创建成功的object所占的memory.
并且重载版的delete是被系统自动调用的
#include <iostream>
#include <stdio.h>
using namespace std;
namespace test1{
class Foo
{
public:
void Print() const{
cout << "Foo::Print const" << endl;
}
void Print(){
cout << "Foo::Print" << endl;
}
};
};
namespace test2 {
class Bad{};
class Foo{
public:
Foo() { cout << "Foo::Foo()" <<endl; }
Foo(int) {cout << "Foo::Foo(int)" << endl; throw "抛出异常";}
static void* operator new(size_t size) {
return malloc(size);
}
static void operator delete(void* pdead, size_t size) {
cout << "void operator delete(void* pdead, size_t size)" <<endl;
free(pdead);
}
static void* operator new(size_t size, void *) {
return malloc(size);
}
static void operator delete(void *, void *) {
cout << "operator delete(void *, void *)" << endl;
}
static void* operator new(size_t size, long extra) {
return malloc(size + extra);
}
static void operator delete(void *pHead, long) {
cout << "operator delete(void *, long)" << endl;
}
static void* operator new(size_t size, long extra, char init) {
return malloc(size + extra);
}
static void operator delete(void *pHead, long, char) {
cout << "operator delete(void *, long, char)" << endl;
free(pHead);
}
};
};
int main(int argc, char *argv[])
{
test2::Foo start;
test2::Foo *p1;
test2::Foo *p2;
test2::Foo *p3 ;
test2::Foo *p4;
test2::Foo *p5 ;
try
{
p1 = new test2::Foo;
p2 = new (&start) test2::Foo;
p3 = new (100)test2::Foo;
p4 = new (100, 'a')test2::Foo;
p5 = new (100)test2::Foo(1);
}
catch (const char* msg)
{
cout << msg<<endl;
}
return 0;
}
Foo::Foo()
Foo::Foo()
Foo::Foo()
Foo::Foo()
Foo::Foo()
Foo::Foo(int)
operator delete(void *, long)
抛出异常
Press any key to continue
引用场景:string中使用重载operator new()的方式,给一块内存添加引用计数,可节省内存空间