C++相关数据结构成员方法的调用 - c++编程基础 - 编程开发
设为首页 加入收藏

TOP

C++相关数据结构成员方法的调用(一)
2018-05-08 06:06:48 】 浏览:133
Tags:相关 数据结构 成员 方法 调用

1.相关数据结构成员方法的调用

class Stack
{
public:
     Stack()
     {
          cout << this << endl;
          cout << "Stack()" << endl;
          mpstack = new int[10];
          mtop = -1;
          msize = 10;
     }
     //explicit:你明确的调用了这个构造函数,我才给你构造对象;否则
     //编译错误   explicit:防止隐式产生临时对象用的!
     //explicit Stack(int size)
     Stack(int size)
     {
          cout << this << endl;
          cout << "Stack(int)" << endl;
          mpstack = new int[size];
          mtop = -1;
          msize = size;
     }
     Stack(int size, int len, int initVal)
     {
          cout << this << endl;
          cout << "Stack(int, int, int)" << endl;
          mpstack = new int[size];
          msize = size;
          mtop = -1;
          for (int i = 0; i < len; ++i)
          {
              mpstack[++mtop] = initVal;
          }
     }
     ~Stack()
     {
          cout << this << endl;
          cout << "~Stack()" << endl;
          delete[]mpstack;
          mpstack = NULL;
     }
     Stack(const Stack &src)
     {
          cout << &src << "=>" <
  
在main()函数里:Stack s1;//调用默认的构造函数Stack s2(20);//调用带有一个整型参的构造函数Stack s3(10,20,15);//调用带有三个整型参的构造函数
Stack s4(s3);//Stack s4=s3;//调用自定义的拷贝构造函数s2=s4;//调用自定义的赋值运算符的重载函数1)Stack s5=Stack(20);//Stack s5=20;//Stack s5(20);//直接调用带有一个整型参的构造函数 Stack s6=Stack(20,15,15);//直接调用带有三个整型参的构造函数 //告诉编译器,帮我产生一个临时对象【这里指定了类名称,叫做显示产生临时对象】 临时对象的生存周期:语句结束,周期就到了。/*C++编译器的编译规则:用临时对象[显示产生的临时对象]拷贝构造函数时,临时对象就被优化掉了,直接构造左值对象就行*/2)Stack s7=(Stack)(20,15,30);//Stack s7=(Stack)30;//Stack s7=Stack(30); //此处是逗号表达式,最终值为30 //调用带有一个整型参的构造函数3)s7=20;//s7.operator=(20);//此处相当于隐式产生临时对象 此句话相当于做了三件事: 1.Stack(int)==>20,即隐式产生临时对象; 2.operator=(const Stack &src(src引用的就是临时对象)),即调用赋值运算符的重载函数; 3.析构临时对象.问题:隐式产生的临时对象为什么不优化?一般隐式的临时对象不是在新对象的创建的情况下产生的,而是在对已存在的对象进行赋值时产生的,而C++的编译规则中临时对象被优化的前提是用临时对象拷贝构造新对象,所以隐式产生的临时对象的创建是不能被优化从而省略掉的,而是在等号赋值之后会被析构。 运算符explicit: 意为明确的,确定的 即你明确的调用了这个构造函数,我才给你构造,否则编译报错。 只能修饰构造函数,是防止隐式产生临时对象用的。 eg:s7=20;此时隐式产生了临时对象,并且调用的是带有一个整型参的构 造函数,所以我们就可以给带有一个整型参的构造函数之前加上 explicit运算符,此处就不会隐式产生临时对象了。 即:explicit Stack(int size);4)Stack *p1=new Stack(); Stack *p2=new Stack(10); Stack *p3=new Stack(10,5,60); //在堆上构造新对象,必须自己delete,否则永远不会析构 delete p1; delete p2; delete p3; 异常: delete (int *)p1; delete (int *)p2; delete (int *)p3; //指针的类型会影响析构的调用,指针调用什么类型,析构什么类型,而这里delete时起始地址没变,所以会释放p1/p2/p3所占用的整块内存,但是不会调用类类型的析构,所以会将p1/p2/p3占用的外部资源弄丢了
Stack *p4=new Stack[3]; //在堆上创建一个对象数组,那么每个对象就只能调用默认构造函数,此处调用三次 delete []p4; //delete三次 异常: delete p4; //整块内存都释放了,但却只释放了Stack[0]上的外部资源,没有释放Stack[1],Stack[2]上的外部资源 new:除了开辟内存,还能调用对象的构造函数 delete:会把堆上的对象先析构,再释放其内存5)Stack *p5=&Stack(10);//栈上构造 //用指针指向临时对象,语句结束,临时对象就析构了 Stack &ref1=Stack(20);//Stack ref1(20);//栈上构造 //用引用来引用临时对象,相当于起别名,即使语句结束,也不会析构2.例题:请给出下面对象创建过程中涉及的方法打印
class Test
{
public:
     Test(int a = 5, int b = 5) :ma(a), mb(b)
     {
          cout << "Test(int, int)" << endl;
     }
     ~Test()
     {
          cout << "~Test()" << endl;
     }
     Test(const Test &src) :ma(src.ma), mb(src.mb)
     {
          cout << "Test(const Test&)" << endl;
     }
     void operator=(const Test &src)
     {
          ma = src.ma; mb = src.mb; cout << "operator=" << endl;
     }
private:
     int ma;
     int mb;
};
Test t1(10, 10);//程序运行时开辟,调用带有两个整型参的构造函数
int main()
{
     Test t2(20, 20);//调用带有两个整型参的构造函数
     Test t3 = t2;/
编程开发网
首页 上一页 1 2 下一页 尾页 1/2/2
】【打印繁体】【投稿】【收藏】 【推荐】【举报】【评论】 【关闭】 【返回顶部
上一篇ACM日期计算(C++实现):输入一个.. 下一篇C和C++字符串问题解析

评论

帐  号: 密码: (新用户注册)
验 证 码:
表  情:
内  容:

最新文章

热门文章

C 语言

C++基础

windows编程基础

linux编程基础

C/C++面试题目