C++：类与对象——对象的特性

于 2025-07-18 22:40:31 发布
阅读量567 收藏 18
点赞数 14
CC 4.0 BY-SA版权
分类专栏： C++ 文章标签： c++ 类与对象——对象的特性
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Yean666/article/details/149454013

声明

        文章是本人初学C++时观看B站黑马程序员的课做的笔记，在此先感谢黑马程序员。本人将核心知识点进行了归纳总结，适合新手。另外，本人写作经验不多，排版和内容难免会有缺陷，恳请批评指正。最后，本文虽然价值实在有限，但还请在转载时标明出处。如果这篇文章能为你提供一点帮助，那么花的时间就是值得的，我也将会持续不定期发布其他内容。

构造函数和析构函数的基本概念

构造函数

构造函数概念

创建对象时为对象的成员属性赋值，构造函数有编译器自动调用，无须手动调用

语法

类名(){} 

注意事项

a.没有返回值，不用写void
b.函数名 与类名相同
c.构造函数可以有参数 可以重载
d.创建对象的时候，构造函数会自动调用，而且只调用一次  

析构函数

析构函数概念

主要作用在对象销毁前系统自动调用，执行一些清理工作

语法

~类名(){}

注意事项

a.没有返回值，不用写void
b.函数名 与类名相同，前加~
c.析构函数不可以有参数的，不可以发生重载
d.对象在销毁前 会自动调用析构函数，而且只会调用一次

example

#include<iostream>
using namespace std;
//对象的初始化和清理
class Person
{
public:
    //构造函数，初始化操作
    Person()
    {
        cout<<"Person构造函数的调用"<<endl;
    }
    //析构函数，清理操作
    ~Person()
    {
        cout<<"Person析构函数的调用"<<endl;
    }
};
//构造和析构都是必须有的实现，如果我们自己不提供，编译器会提供一个空实现的构造和析构
void test01()
{
    Person p;//在栈上的数据，test01执行完毕后，释放这个对象
}
int main()
{
    test01();
    Person q;
    system("pause");
    return 0;
}

构造函数的分类及其调用

两种分类方式

按参数分为：无参构造/默认构造(Person()) 和 有参构造(Person(int a))
按类型分为：普通构造 和 拷贝构造(Person(const Person &p))

三种调用方式

括号法（好用！）

    a.Person p1; //无参 注意1！调用默认构造函数时，不要加(),编译器会当成函数声明
    b.Person p2(10); //有参
    c.Person p3(p2) //拷贝

显示法

a.Person p4=Person(10); //有参
b.Person p5=Person(p4); //拷贝
c.Person(10) //匿名对象 特点：当前行执行结束后，系统会立即收掉匿名对象
//注意2！不要利用拷贝构造函数 初始化匿名对象 编译器会认为Person(p3)===Person p，对象声明

隐式转化法a.Person p6=10;//有参 相当于 Person p7=Person(10) 相当于 Person P7(10);

b.Person p7=p6;//拷贝

注意事项

a.调用默认构造函数时，不要加(),编译器会当成函数声明
b.不要利用拷贝构造函数 初始化匿名对象 编译器会认为Person(p3)==Person p3，对象声明

example

#include<iostream>
using namespace std;
//构造函数的分类及调用
//分类
//按照参数分类 无参构造(默认构造)和 有参构造
//按照类型分类 普通构造 和 拷贝构造
class Person
{
public:
    //构造函数
    //普通构造函数
    Person()//无参构造(默认构造)
    {
        cout<<"Person的无参构造函数调用"<<endl;
    }
    Person(int a)//有参构造
    {
        age=a;
        cout<<"Person的有参构造函数调用"<<endl;
    }
    //拷贝构造函数
    Person(const Person &p)
    {
        cout<<"Person的拷贝构造函数调用"<<endl;
        age=p.age;
    }
    ~Person()
    {
        cout<<"Person的析构函数调用"<<endl;
    }
    int age;
};
//调用
void test01()
{
    //1.括号法
    Person p1;//默认构造函数的调用
    Person p2(10);//有参构造函数
    Person p3(p2);//拷贝构造函数
    cout<<"p2的年龄为："<<p2.age<<endl;
    cout<<"p3的年龄为："<<p3.age<<endl;
    
    cout<<"\n\n"<<endl;

    //2.显示法
    Person p4=Person(10);//有参构造函数
    Person p5=Person(p4);//拷贝构造函数
    Person(10);//匿名对象，当前行执行完后，系统立即回收
    cout<<"aaaa"<<endl;

    cout<<"\n\n"<<endl;

    //3.隐式转化法
    Person p6=10; //有参构造函数
        Person p7=p6;//拷贝构造函数
}
int main()
{
    test01();
    system("pause");
    return 0;
}
/*
Person的无参构造函数调用
Person的有参构造函数调用
Person的拷贝构造函数调用
p2的年龄为：10
p3的年龄为：10

Person的有参构造函数调用
Person的拷贝构造函数调用
Person的有参构造函数调用
Person的析构函数调用
aaaa

Person的有参构造函数调用
Person的拷贝构造函数调用
Person的析构函数调用
Person的析构函数调用
Person的析构函数调用
Person的析构函数调用
Person的析构函数调用
Person的析构函数调用
Person的析构函数调用
请按任意键继续. . .
*/

拷贝构造函数调用时机

(1).使用一个已经创建完毕的对象来初始化一个新对象

(2).值传递的方式给函数参数传值

(3).值方式返回局部对象

example

#include<iostream>
using namespace std;
class Person
{
public:
    Person()
    {
        cout<<"Person默认构造函数调用"<<endl;
    }
    Person(int age)
    {
        cout<<"Person有参构造函数调用"<<endl;
        m_Age=age;
    }
    Person(const Person & p)
    {
        cout<<"Person拷贝构造函数调用"<<endl;
        m_Age=p.m_Age;
    }
    ~Person()
    {
        cout<<"Person析构函数调用"<<endl;
    }
    int m_Age;
};
//1.使用一个已经创建完毕的对象来初始化一个新对象
void test01()
{
    Person p1(20);
    Person p2(p1);
    cout<<"P2的年龄为："<<p2.m_Age<<endl;
}
//2.值传递的方式给函数参数传值
void doWork1(Person p)//拷贝一个新的p接受p
{
    p.m_Age=1000;
}
void test02()
{
    Person p;
    p.m_Age=10;
    doWork1(p);//值传递，把上面的p值传递给doWork
    cout<<"p的年龄为："<<p.m_Age<<endl;//不改变实参
}
//3.值方式返回局部对象
Person doWork2()
{
    Person p3;
    cout<<"p3的地址："<<(int*)&p3<<endl;
    return p3;//不返回p3,返回时根据p3拷贝新的对象
}
void test03()
{
    Person p4=doWork2();
    cout<<"p4的地址："<<(int*)&p4<<endl;
}
int main()
{
    test01();
    cout<<"\n"<<endl;
    test02();
    cout<<"\n"<<endl;
    test03();
    system("pause");
    return 0;
}
/*
Person有参构造函数调用//p1的构造函数
Person拷贝构造函数调用//p2的构造函数
P2的年龄为：20//验证拷贝数据
Person析构函数调用//p1析构
Person析构函数调用//p2析构


Person默认构造函数调用//p的构造函数
Person拷贝构造函数调用//创建的拷贝函数的构造函数
Person析构函数调用//拷贝的析构
p的年龄为：10//验证形参不改变实参
Person析构函数调用//p的解析


Person默认构造函数调用//p3的构造函数
p3的地址：00AFF71C//p3地址
Person拷贝构造函数调用//return时创建新p拷贝p3，新p的拷贝构造函数调用
Person析构函数调用//p3的析构
p4的地址：00AFF810//拷贝到新p赋到p4，展示地址
Person析构函数调用//拷贝函数赋给p4后的析构
请按任意键继续. . .
*/

构造函数的调用规则

默认情况下，C++编译器至少给一个类添加3个函数
1.默认构造函数（无参）（空实现）
2.默认析构函数（无参）（空实现）
3.默认拷贝构造函数（值拷贝）
用户定义有参构造函数，C++不在提供默认无参构造，但会提供默认拷贝构造
用户定义拷贝构造函数，C++不会在提供其他构造函数

深拷贝和浅拷贝

浅拷贝：简单的赋值拷贝操作,易发生重复释放堆区内存
深拷贝：在堆区重新申请空间，进行拷贝操作

错误代码分析

#include<iostream>
using namespace std;
class Person
{
public:
    Person()
    {
        cout<<"Person的默认构造函数调用"<<endl;
    }
    Person(int age,int height)
    {
        m_Age=age;
        m_Height=new int(height);
    //传入形参的数据地址开辟一块内存,地址给m_Height
        cout<<"Person的有参构造函数调用"<<endl;
    }
    ~Person()
    {
        //析构代码，将堆区开辟数据做释放操作
        if(m_Height!=NULL)
        {
            delete m_Height;
            m_Height=NULL;
        }
        cout<<"Person的析构函数调用"<<endl;
    }
    int m_Age;
    int *m_Height;
};
void test01()
{
    Person p1(18,170);
    cout<<"p1的年龄为："<<p1.m_Age<<"身高为："<<*p1.m_Height<<endl;
    Person p2(p1);
    cout<<"p2的年龄为："<<p2.m_Age<<"身高为："<<*p2.m_Height<<endl;
}
//由于进行浅拷贝，p1仅仅将m_Height的地址赋给p2,于是p1,p2的m_Height指向同一个堆区内存
//test01执行结束，先析构p2，此时将堆区m_Height空间释放，在析构p1时，重复释放堆区内存int main()
{
    test01();
    system("pause");
    return 0;
}

改为深拷贝来解决//自己实现拷贝构造函数，重新开辟一块新的堆区内存（问：怎么实现深拷贝，自己写一个拷贝构造函数）

Person(const Person &p)//const是防止被复制的数据被篡改
{
        cout<<"拷贝构造函数的调用"<<endl;
        m_Age=p.m_Age;
        m_Height=new int(*p.m_Height);
}

类对象作为类成员

1.先构造类对象，在构造类自身
2.析构函数相反

example

#include<iostream>
using namespace std;
#include<string>
class Phone
{
public:
    Phone(string pName,int Prize)
    {
        cout<<"Phone的构造函数调用"<<endl;
        m_PName=pName;
        m_Prize=Prize;
    }
    ~Phone()
    {
        cout<<"Phone的析构函数调用"<<endl;
    }
    string m_PName;
        int m_Prize;
};
class Person
{
public:
    //Phone m_Phone=pName 隐式转化法
    Person(string name,string pName,int Prize):m_Name(name),m_Phone(pName,Prize)//该处调用Phone的含参构造函数
    //Person类里面的成员对象Phone，有两个，其关键在Phone类里的构造函数。
    {
        cout<<"Person的构造函数调用"<<endl;
    }
    ~Person()
    {
        cout<<"Person的析构函数调用"<<endl;
    }
    string m_Name;
    Phone m_Phone;
};
//当其他类对象作为本类成员，构造时候先构造类对象，在构造自身
//析构函数相反
void test01()
{
    Person p("张三","华为",1000);
    cout<<p.m_Name<<" "<<p.m_Phone.m_PName<<" "<<p.m_Phone.m_Prize<<endl;
}
int main()
{
    test01();
    system("pause");
    return 0;
}
/*
Phone的构造函数调用
Person的构造函数调用
张三 华为 1000
Person的析构函数调用
Phone的析构函数调用
请按任意键继续. . .
*/

对比：

#include<iostream>
using namespace std;
#include<string>
class Phone
{
public:
    Phone()                                      
    {                                            
        cout<<"Phone的默认构造函数调用"<<endl;
    }                                            
    Phone(string pName,int prize)
    {
        cout<<"Phone的含参构造函数调用"<<endl;
        m_PName=pName;
        m_Prize=prize;
    }
    ~Phone()
    {
        cout<<"Phone的析构函数调用"<<endl;
    }
    string m_PName;
    int m_Prize;
};
class Person
{
public:
    Person(string name,string pName,int prize)
    {                                         
        m_Name=name;                      
        m_Phone.m_PName=pName;            
        m_Phone.m_Prize=prize;            
        cout<<"Person的构造函数调用"<<endl;
    }                                         
    ~Person()
    {
        cout<<"Person的析构函数调用"<<endl;
    }
    string m_Name;
    Phone m_Phone;
};
void test01()
{
    Person p("张三","华为",3000);
    cout<<p.m_Name<<" "<<p.m_Phone.m_PName<<" "<<p.m_Phone.m_Prize<<endl;
}
int main()
{
    test01();
    system("pause");
    return 0;
}
/*
Phone的默认构造函数调用
Person的构造函数调用
张三 华为 3000
Person的析构函数调用
Phone的析构函数调用
请按任意键继续. . .
*/

小结

(1).第一个里面用的Public有参构造函数用的初始化列表调用了Phone的有参构造函数
(2).第二个里面用的Public有参构造函数里赋值的过程中调用了Phone的无参构造函数

静态成员

静态成员变量

(1).所用成员共享同一份数据
(2).在编译阶段分配内存(全局区)
(3).类内声明，类外初始化
(4).静态成员变量也是有访问权限的
(5).两种访问方式
a.通过对象进行访问
b.通过类名进行访问

静态成员函数

(1).所有对象共享同一个函数
(2).静态成员函数只能访问静态成员变量
(3).静态成员函数也是有访问权限的
(4).两种访问方式
a.通过对象进行访问
b.通过类名进行访问

example

#include<iostream>
using namespace std;
#include<string>

class Person
{
public:
    //1.所有对象都共享同一份数据
    //2.编译阶段就分配内存
    //3.类内声明，类外初始化操作
    static int m_A;
    static int m_B;
};
int Person::m_A=100;
int Person::m_B=300;
void test01()
{
    Person p1;
    cout<<p1.m_A<<endl;//通过类名进行访问
    Person p2;
    p2.m_A=200;
    cout<<p1.m_A<<endl;
//共享数据，p2里面修改m_A,p1里面的m_A也修改了
}
void test02()
{
    cout<<Person::m_B<<endl;//通过对象访问
}
int main()
{
    test01();
    test02();
    system("pause");
    return 0;
}
/*
100
200
300
请按任意键继续. . .
*/

example

#include<iostream>
using namespace std;
class Person
{
public:
    static void func()
    {
        cout<<"static void func的调用"<<endl;
        m_A=100;//只能改静态的m_A,不能改m_B
        cout<<m_A<<endl;    
    }
    static int m_A;
    int m_B;
};
int Person::m_A=0;
void test01()
{
    //1.通过对象访问
    Person p;
    p.func();
}
void test02()
{
    //2.通过类名访问
    Person::func();
}
int main()
{
    test01();
    test02();
    system("pause");
    return 0;
}
/*
static void func的调用
100
static void func的调用
100
请按任意键继续. . .
*/

C++对象模型和this指针

1.在C++中，类内的成员变量和成员函数分开存储，只有非静态成员变量才属于类的对象上
2.空对象占用空间内存为1,非空对象占用空间内存不用算1

this指针概念

本质是指针常量
this指针指向被调用的成员函数所属的对象
形参和成员变量同名时，可用this指针来区分
在非静态成员函数中返回对象本身，可使用return *this

example

#include<iostream>
using namespace std;
//成员变量和成员函数分开储存
class Person01
{

};
class Person02
{
public:
    int m_A;//非静态成员变量 属于类的对象上
    static int m_B;//静态成员变量 不属于类的对象上
    void func01()//非静态成员函数 不属于类的对象上
    {

    }
    static void func02()//静态成员函数 不属于类的对象上
    {

    }
};
int Person02::m_B=0;
void test01()
{
    Person01 p;
    cout<<"size of p = "<<sizeof(p)<<endl;
    //空对象占用内存空间为1
    //C++编译器会给每个空对象也分配一个字节空间，是为了区分空对象占内存的位置
    //每个空对象也应该有一个独一无二的的内存地址
}
void test02()
{
    Person02 p;
    cout<<"size of p = "<<sizeof(p)<<endl;
    //不是空对象，内存空间不用算占1的
}
int main()
{
    test01();
    test02();
    system("pause");
    return 0;
}
/*
size of p = 1
size of p = 4
请按任意键继续. . .
*/

example

#include<iostream>
using namespace std;
class Person
{
public:
    Person ( int age )
    {
        this -> age = age;//解决名称冲突
    }
    Person& PersonAddAge1 ( Person &p )
    {
        this -> age += p.age;
        return *this;
    }//this指向调用对象的地址，*this是引用，故返回值为Person&型
    Person PersonAddAge2 ( Person &p )
    {
        this -> age += p.age;
        return *this;
    }//拷贝构造函数，用新对象拷贝数据
    //PersonAddAge1与PersonAddAge2对比分析
    //1.&代表了返回值是下面调用该函数p2的引用
    //2.没有&代表返回的是p2"拷贝了p2里面的内容
    int age;
};
void test01()
{
    Person p1 (18);
    cout << "p1的年龄为：" << p1.age << endl;
}
void test02()
{
    Person p1(10);
    Person p2(10);
    //链式编程思想
    p2.PersonAddAge2(p1).PersonAddAge2(p1);
    cout << "p2的年龄为：" << p2.age << endl;
    p2.PersonAddAge1(p1).PersonAddAge1(p1);
    cout << "p2的年龄为：" << p2.age << endl;
    //p2.PersonAddAge1(p1)的返回值是p2
    //p2.PersonAddAge2(p1)的返回值是p2"
}
int main()
{
    test01();
    test02();
    system("pause");
    return 0;
}
/*
p1的年龄为：18
p2的年龄为：20
p2的年龄为：40
请按任意键继续. . .
*/

空指针访问成员函数

1.C++中空指针可以调用成员函数，但要注意有没有用到this指针
2.如果用到this指针，需要加以判断

example

#include<iostream>
using namespace std;
class Person
{
public:
    void showClassName()
    {
        cout << "this is Person class" << endl;
    }
    void showPersonAge()
    {
        if (this == NULL)
        {
            return;
        }
        cout << "Age = " << m_Age << endl;
        //m_Age用到了this指针，this->m_Age
        //加以判断后使用
    }
    int m_Age;
};
void test01()
{
    Person * p = NULL;
    p->showClassName();
    p->showPersonAge();
}
int main()
{
    test01();
    system("pause");
    return 0;
}

const修饰成员函数

常函数

语法：

返回值类型 函数名（XXX）const

本质是修饰this指针
函数内不可修改成员属性，成员属性加关键字mutable后可以修改

常对象

语法：

//声明对象前加上const，例如

const Person p;

常对象的成员属性不能修改，成员属性加关键字mutable后可以修改
常对象只能调用常函数

example

#include<iostream>
using namespace std;
class Person
{
public:
    void func()
    {
        m_A = 100;
    }
    //常函数
    void showPerson() const//本质是修饰this指针
    {
        this->m_B = 100;//m_B = 100也可以
    }//m_A不可以修改，m_B可以修改
    int m_A;
    mutable int m_B;
};
//常对象
void test01()
{
    const Person p;//在对象前加const，变为常对象
    p.m_B = 150;//m_A不可以修改
    cout << p.m_B << endl;
    p.showPerson();
    cout << p.m_B << endl;
}//常对象不能调用p.func()等普通成员函数，
//因为普通成员函数可以修改属性
int main()
{
    test01();
    system("pause");
    return 0;
}
/*
150
100
请按任意键继续. . .
*/
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值