• 设为首页
  • 点击收藏
  • 手机版
    手机扫一扫访问
    迪恩网络手机版
  • 关注官方公众号
    微信扫一扫关注
    公众号

C/C++(C++返回对象与应用区别,类成员的存储)

原作者: [db:作者] 来自: [db:来源] 收藏 邀请

返回对象与应用区别:

拷贝构造器发生的时机:

1.构造新对象 A a, A b = a;
2.传参或返回对象

对于普通变量来说,传引用效果不是很明显,对于类对象而言,传对象效果很高。
传引用等价于扩大了原对象的作用域。

#include<iostream>
using namespace std;
class A
{
public:
    A()//无参构造器
    {
        cout<<this<<" constructor"<<endl;
    }
    ~A()//析构器
    {
        cout<<this<<" destructor"<<endl;
    }
    A(const A & another)//拷贝构造器
    {
        cout<<this<<" cpy constructor from"<<&another<<endl;
    }
    A & operator=(const A & another)//运算符重载
    {
        cout<<this<<" operator"<<&another<<endl;
    }
};

void func(A a)
{
    
}
void func1(A &a)
{

}

int main()
{
    A x;//调用构造器
    A y = x;//拷贝构造器
    func(x);//调用拷贝构造器
/*
0x61fe9e constructor
0x61fe9d cpy constructor from0x61fe9e
0x61fe9f cpy constructor from0x61fe9e
0x61fe9f destructor
0x61fe9d destructor
0x61fe9e destructor
有构造器就有析构器
*/  
    
    func1(x);//没有调用任何构造器
/*
0x61fe9e constructor
0x61fe9d cpy constructor from0x61fe9e
0x61fe9f cpy constructor from0x61fe9e
0x61fe9f destructor
0x61fe9d destructor
0x61fe9e destructor
*/
    
    return 0;
}


栈上的对象是可以返回的,但不能返回栈上的引用(除非返回对象本身)。

#include<iostream>
using namespace std;
class A
{
public:
    A()//无参构造器
    {
        cout<<this<<" constructor"<<endl;
    }
    ~A()//析构器
    {
        cout<<this<<" destructor"<<endl;
    }
    A(const A & another)//拷贝构造器
    {
        cout<<this<<" cpy constructor from"<<&another<<endl;
    }
    A & operator=(const A & another)
    {
        cout<<this<<" operator"<<&another<<endl;
    }
};

A func(A &a)
{
    return a;
}

int main()
{
    A x;//调用构造器
    func(x);//发生了一次拷贝构造,但上述没有返回值的时候是没有任何构造器 
/*
0x61feae constructor
0x61feaf cpy constructor from0x61feae
0x61feaf destructor
0x61feae destructor
*/
    return 0;
}

int main()
{
    A x;//调用构造器
    A t;//调用构造器
    t = func1(x);//x作为参数传入并没有调用构造器,而是返回大时候调用了拷贝构造器,(func1函数返回的值拷贝到临时变量中,再从临时变量拷贝到t,用来运算符重载)
    cout<<"&t "<<&t<<endl;
/*
0x61fe9e constructor
0x61fe9d constructor
0x61fe9f cpy constructor from0x61fe9e
0x61fe9d operator0x61fe9f
0x61fe9f destructor
&t 0x61fe9d
0x61fe9d destructor
0x61fe9e destructor
*/
    return 0;
}
A func()
{
    A b;
    return b;
}
int main()
{
    A t;
    t = func();
    cout<<"&t "<<&t<<endl;

/*
0x61fe9e constructor
0x61fe9f constructor
0x61fe9e operator0x61fe9f
0x61fe9f destructor
&t 0x61fe9e
0x61fe9e destructor
*/

    return 0;
}
A& func()
{
    A b;
    return this;//是可以的,因为本身对象还没有销毁,如果返回的是b,返回后func销毁,有时候会正确,有时候会错误。
}

string类字符拼接的实现

mystring mystring::operator+(const mystring & another)
{
    mystring tmp;//
    delete []tem._str;
    int len = strlen(this->_str);
    len += strlen(another._str);
    tmp._str = new char[len+1];

    memset(tem._str,0,len+1);//必须要的
    strcat(tem._str,this->_str);
    strcat(tem._str,another._str);
    return tmp;
}

c与c++关于字符串的处理对比
c基于字符数组,利用一些方法strcpy,strlen,strcat等操作。
c++所有操作围绕字符指针。通过此指针进行操作,整体设计思想是面向对象思想。

面向对象的思想练习

#include<iostream>
#include<unistd.h>
#include<iomanip>
#include<time.h>

using namespace std;
class Clock
{
private:
    int hour;
    int min;
    int sec;
public:
    Clock()
    {
        time_t t = time(NULL);
        struct tm ti = *localtime(&t);
        hour = ti.tm_hour;
        min = ti.tm_min;
        sec = ti.tm_sec;
    }
    void run()
    {
        while(1)
        {
            show();//显示函数
            tick();//数据跟新函数
        }
    }
private:
    void show()
    {
        system("cls");//windows下的清屏cls
        cout<<setw(2)<<setfill('0')<<hour<<":";
        cout<<setw(2)<<setfill('0')<<min<<":";
        cout<<setw(2)<<setfill('0')<<sec;
    }
    void tick()
    {
        sleep(1);
        if(++sec == 60)
        {
            sec = 0;
            min += 1;
            if(++min == 60)
            {
                min = 0;
                hour += 1;
                if(++hour == 24)
                {
                    hour = 0;
                }
            }
        }
    }
}

int main()
{
    Clock c;
    c.run();

    return 0;
}

类成员的存储

#include<iostream>
using namespace std;
class Time
{
private:
    int hour;
    int min;
    int sec;
public:
    Time(int h,int m,int s)
        :hour(h),min(m),sec(s)
        {
        
        }
    void display()
    {
        cout<<hour<<min<<sec<<endl;
        //<=>
        //cout<<this->hour<<this->min<<this->sec<<endl;
    }
/*
    void display(Time *t)
    {
        cout<<t->hour<<t->min<<t->sec<<endl;//自己通过显式传参。
    }
*/

};
int main()
{
    Time t(1,2,3),t1(2,3,4),t2(4,5,6);
    cout<<sizeof(Time)<<"----"<<sizeof(t)<<endl;
    t.display();
    t1.display();
    t2.display();

    return 0;
}

上述代码display()函数,三个对象公用。对象在调用的时候传递了自己对象this。
对象拥有自己的存储空间,函数部分代码是公用的。表现的形式是每个对象在调用的时候传进自己的对象this。

注意事项

1,不论成员函数在类内定义还是在类外定义,成员函数的代码段都用同一种方式存储。
2,不要将成员函数的这种存储方式和 inline(内置)函数的概念混淆。inline 的逻辑意义是将函数内嵌到调用代码处,减少压栈与出栈的开支。
3,应当说明,常说的“某某对象的成员函数”,是从逻辑的角度而言的,而成员函数的存储方式,是从物理的角度而言的,二者是不矛盾的。类似于二维数组是逻辑概念,而物理存储是线性概念一样。


鲜花

握手

雷人

路过

鸡蛋
该文章已有0人参与评论

请发表评论

全部评论

专题导读
上一篇:
C++异常发布时间:2022-07-13
下一篇:
C#批量向数据库插入数据发布时间:2022-07-13
热门推荐
阅读排行榜

扫描微信二维码

查看手机版网站

随时了解更新最新资讯

139-2527-9053

在线客服(服务时间 9:00~18:00)

在线QQ客服
地址:深圳市南山区西丽大学城创智工业园
电邮:jeky_zhao#qq.com
移动电话:139-2527-9053

Powered by 互联科技 X3.4© 2001-2213 极客世界.|Sitemap