标准C++之运算符重载和虚表指针

1 -> *运算符重载

//autoptr.cpp

#include<iostream>

#include<string>

using namespace std;

struct date{

int year;

int month;

int day;

};

struct Person{

string name;

int age;

bool gender;

double salary;

date birthday;

Person() {cout<<"创建Person对象在"<<this<<endl;}

~Person(){cout<<"释放Person对象在"<<this<<endl;}

};

class autoptr{

Person *p;

static int cnt;

public:

autoptr(Person *p):p(p){}

autoptr(const autoptr& a):p(a.p){++cnt;}

~autoptr(){

cout<<"cnt="<<autoptr::cnt<<endl;

if(--cnt==0)

delete p;

}

Person* operator->() {return p;}  //将对象模拟成指针

Person& operator*() {return *p;}

};

int autoptr::cnt=0;

int main()

{

//autoptr a(new Person());

autoptr a=new Person();

autoptr b=a;

autoptr c=a;

cout<<"=============================="<<endl;

a->name="zhangming";

cout<<"name:"<<(*a).name<<endl;

a->birthday.year=1993;

a->birthday.month=10;

a->birthday.day=9;

cout<<"birthday:"<<(*a).birthday.year<<"/"<<(*a).birthday.month

<<"/"<<(*a).birthday.day<<endl;

cout<<"==============================="<<endl;

return 0;

}

2.赋值运算符=重载,实现堆栈类

//stack.cpp

#include<iostream>

#include<string>

using namespace std;

typedef unsigned int uint;

class Stack

{

public:

Stack(uint n):mem(new string[n]),max(n),len(0){}

Stack(const Stack &s):mem(new string[s.max]),

max(s.max),len(s.len){}

uint max_size()const {return max;}

uint size()const {return len;}

Stack& push(const string &s)

{

if(len>=max) throw 1;

mem[len++]=s;

return *this;

}

string pop()

{

if(len==0) throw 0;

return mem[--len];

}

~Stack(){ delete[]mem; }

void print()const{

for(int i=0;i<len;i++)

{

cout<<mem[i]<<" ";

}

cout<<endl;

}

//重载赋值运算符

Stack& operator=(const Stack &s)

{

if(*this==s)  return *this;  //考虑到自己给自己赋值

delete[]mem; //释放原来的空间

this->mem=new string[s.max];

this->len=s.len;

this->max=s.max;

for(int i=0;i<len;i++)

{

mem[i]=s.mem[i];

}

return *this;

}

private:

string* mem;

uint max;

uint len;

};

int main()

{

Stack s1(5);

Stack s2(s1); //错误,s1与s2同时指向同一块内存,

//致使delete重复释放,

//可以使用拷贝构造函数解决

Stack s3(8);

s1.push("1").push("2").push("3").push("4").push("5");

s1.print();

s1.pop();

s1.pop();

s1.print();

s2.push("zhangming").push("wangwu");

s2.print();

s3=s1;   //s3.operator=(s1)

s3.print();  //1 2 3

s1=s2;

s1.print();  //zhangming wangwu

s3=s3;

s3.print();  //1 2 3

return 0;

}

3.new delete 运算符重载

//ND.cpp

#include<iostream>

using namespace std;

const int max_size=1000;

int mem[max_size];

class A

{

public:

A(){cout<<"A()"<<endl;}

~A(){cout<<"~A()"<<endl;}

static void* operator new(size_t bytes)  //bytes=sizeof(A)

{

cout<<"new"<<endl;

alloc=bytes;  //即alloc=sizeof(A)

if(alloc>max_size) throw 0;

return (mem+alloc);

}

static void operator delete(void *p)

{

cout<<"delete"<<endl;

alloc=0;

}

void init(int n){

memset(mem,max_size,sizeof(int));

for(int i=0;i<n;i++)

{

mem[i]=i;

}

}

void show(){

for(int i=0;i<alloc;i++)

{

cout<<mem[i]<<" ";

}

cout<<endl;

}

private:

static int alloc;

int num;

char name[10];

};

int A::alloc=0;

int main()

{

A *a=new A;  //实参实际上为sizeof(A)

a->init(5);  //给分配的前五个元素赋初值,剩余元素赋0

a->show();

delete a;

return 0;

}

4.虚函数与虚表指针

//virtual.cpp

#include<iostream>

using namespace std;

class A{

int d;

public:

virtual void f(){cout<<"A类的虚函数"<<endl;}

virtual void g(){cout<<this<<","<<&d<<endl;}

int* get_d(){return &d;}

};

class B:public A{

int d;

public:

void f(){cout<<"B类的虚函数"<<endl;}

void g(){cout<<this<<","<<get_d()<<endl;}

void k(){}

void m(){}

void n(){}

};

int main()

{

A *p=new A;

A *q=new B;

p->f();  //输出:A类的虚函数

q->f();  //输出:B类的虚函数

p->g();

q->g();

memcpy(q,p,4);//让q所指对象的虚表指针指向A类

q->f();  //输出:A类的虚函数

delete p;

delete q;

cout<<"================="<<endl;

cout<<sizeof(A)<<endl;

cout<<sizeof(B)<<endl;

cout<<"================="<<endl;

return 0;

}

时间: 2024-10-06 11:44:40

标准C++之运算符重载和虚表指针的相关文章

C++运算符重载的妙用

运算符重载(Operator overloading)是C++重要特性之中的一个,本文通过列举标准库中的运算符重载实例,展示运算符重载在C++里的妙用.详细包含重载operator<<,operator>>支持cin,cout输入输出.重载operator[],实现下标运算.重载operator+=实现元素追加:重载operator()实现函数调用.假设你对C++的运算符重载掌握的游刃有余.那就无需继续往下看了. 运算符重载带来的优点就是--让代码变得简洁.以下将展示几个标准库因使

新标准C++程序设计读书笔记_运算符重载

形式 返回值类型 operator 运算符(形参表) { …… } 运算符重载 (1)运算符重载的实质是函数重载(2)可以重载为普通函数,也可以重载为成员函数 1 class Complex 2 { 3 public: 4 double real,imag; 5 Complex( double r = 0.0, double i= 0.0 ):real(r),imag(i) { } 6 Complex operator-(const Complex & c); 7 }; 8 9 Complex

运算符重载

关键字:operator 相见:<高质量程序设计指南> P255 如果运算符被重载为全局函数,那么只有一个参数的运算符叫做一元运算符,有两个参数的运算符叫做二元运算符. 如果运算符被重载为类的成员函数,那么一元运算符没有参数(但是++和--运算符的后置版本除外),二元运算符只有右侧参数,因为对象自己成了左侧参数. 运算符重载的特殊性 如果重载为成员函数,则this对象发起对它的调用 如果重载为全局函数,则第一个参数发起对它的调用 禁止用户发明该语言运算符集合中不存在的运算符 除了函数调用运算符

第十章 运算符重载

第十章 运算符重载 1.运算符重载的方法 (实质:函数重载) *一般格式: 函数类型名operator 运算符名称(参数表){函数体:} 2.运算符重载的规则 *不允许定义新的运算符 *允许重载的运算符 双目运算符 +(加法)  - (减法)  * (乘法) / (除法)   %(取模) 关系运算符 ==(等于) != (不等)  <   >   <=   >= 逻辑运算符 ||(或)   && (与)  !(非) 单目运算符 + (正)  -(负)   *(指针)

C++哪些运算符重载可以重载?

运算符重载是C++极为重要的语言特性之一,本文将用代码实例回答--C++哪些运算符可以重载?如何重载?实现运算符重载时需要注意哪些? 哪些运算符可以重载,哪些不可重载? C++98,C++0x,C++11对"哪些运算符重载可以重载"有一致的规定,具体如下: 其中,很少使用的是","(逗号运算符). 标准同样规定了不可重载的运算符: 其中,"::"是作用域运算符, "?:"是条件运算符. 两个较少使用的运算符是 .* 和 -&g

嵌入式linux C++语言(六)——运算符重载

嵌入式linux C++语言(六)--运算符重载 运算符重载的本质是函数重载. 一.重载基础 1.运算符重载的语法 返值类型 operator 运算符名称(形参表列){    重载实体;} 2.友元重载 可以将运算符重载函数声明位友元函数 #include <iostream> using namespace std; class Complex { public:     Complex(float x=0, float y=0)         :_x(x),_y(y){}     voi

C++ 关于运算符重载

转载来源:http://c.biancheng.net/cpp/biancheng/view/216.html 重载运算符的函数一般格式如下:    函数类型 operator 运算符名称 (形参表列)    {        // 对运算符的重载处理    } 例如,想将”+”用于Complex类(复数)的加法运算,函数的原型可以是这样的:    Complex operator+ (Complex& c1, Complex& c2);在上面的一般格式中,operator是关键字,是专门

运算符重载详解

1.运算符重载定义: C++中预定义的运算符的操作对象只能是基本数据类型.但实际上,对于许多用户自定义类型(例如类),也需要类似的运算操作.这时就必须在C++中重新定义这些运算符,赋予已有运算符新的功能,使它能够用于特定类型执行特定的操作.运算符重载的实质是函数重载,它提供了C++的可扩展性,也是C++最吸引人的特性之一. 运算符重载是通过创建运算符函数实现的,运算符函数定义了重载的运算符将要进行的操作.运算符函数的定义与其他函数的定义类似,惟一的区别是运算符函数的函数名是由关键字operato

运算符重载具体解释

1.运算符重载定义: C++中提前定义的运算符的操作对象仅仅能是基本数据类型. 但实际上.对于很多用户自己定义类型(比如类),也须要类似的运算操作.这时就必须在C++中又一次定义这些运算符,赋予已有运算符新的功能,使它可以用于特定类型运行特定的操作.运算符重载的实质是函数重载,它提供了C++的可扩展性,也是C++最吸引人的特性之中的一个. 运算符重载是通过创建运算符函数实现的,运算符函数定义了重载的运算符将要进行的操作. 运算符函数的定义与其它函数的定义类似,惟一的差别是运算符函数的函数名是由k