首页 > 编程语言 >彼岸花开C++，类和对象（下）

彼岸花开C++，类和对象（下）

时间：2024-08-14 10:26:20浏览次数：17  
标签：对象 成员 C++ month int 彼岸花 year day

目录

对类和对象的深层理解

（1）再谈构造函数

（2）Static成员

（3）友元

（4）内部类

（5）匿名对象

（6）再次理解类和对象

对类和对象的深层理解

（1）再谈构造函数

1.构造函数体赋值

在创建对象时，编译器通过调用构造函数，给对象中各个成员变量一个合适的初始值。

class Date
{
public:
    Date(int year,int month,int day)
    {
        _year = year;
        _month = month;
        _day = day;
    }
private:
    int _year;
    int _month;
    int _day;
};

虽然上述构造函数调用之后，对象中已经有了一个初始值，但是不能将其称为对对象中成员变量的初始化，构造函数体中的语句只能将其称为赋初值，而不能称作初始化。因为初始化只能初始化一次，而构造函数体内可以多次赋值。

2.初始化列表

初始化列表：以一个冒号开始，接着是一个逗号分隔的数据成员列表，每个“成员变量”后面跟一个放在括号中的初始值或表达式。

class Date
{
public:
    Date(int year,int month,int day)
    : _year(year) ,_month(month) ,_day(day){}
    
private:
    int _year;
    int _month;
    int _day;
};

Note：

1.每个成员变量在初始化列表中只能出现一次（初始化只能初始化一次）

2.类中包含以下成员，必须在初始化列表位置进行初始化：

  • 引用成员变量
  • const成员变量
  • 自定义类型成员（且该类没有默认构造函数时）
class A
{
public:
    A(int a)
    :_a(a)
    {}
private:
    int _a;
};

class B
{
public:
    // 可以理解为初始化列表是对象的成员变量的定义的地方
    B(int a,int ref)
    : _aobj(a), _ref(ref), _n(10)
    {}
private:
    // 必须初始化列表的
    A _aobj;        // 没有默认构造函数(不用传参数就能调用过的构造函数)
    int& _ref;      // 引用
    const int _n;   // const
    // 成员变量的声明
};

int main()
{
    B b(1,2); // 对象定义
}

3.尽量使用初始化列表初始化，因为不管你是否使用初始化列表，对于自定义类型成员变量，一定会先使用初始化列表初始化。

#include <iostream>
using namespace std;

class Time
{
public:
    Time(int hour = 0)
    :_hour(hour)
    {
        cout << "Time()" << endl;
    }
private:
    int _hour;
};

class Date
{
public:
    Date(int day)
    {}
private:
    int _day;
    Time _t;
};

int main()
{
    Date d(1);
}

运行结果：

4.成员变量在类中的声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关。

#include <iostream>
using namespace std;

class A
{
public:
    A(int a)
    :_a1(a) ,_a2(_a1)
    {}
    
    void Print()
    {
        cout << _a1 << " " << _a2 << endl;
    }
private:
    int _a2;
    int _a1;
};

int main()
{
    A aa(1);
    aa.Print();
    
    system("pause");
    return 0;
}

运行结果：

第一个值为1，第二个值为随机值。

将这里的_a1与_a2声明次序调换一下，结果就会是两个一，就不会出现随机值。

3.explicit关键字

构造函数不仅可以构造与初始化对象，对于单个参数或者除第一个参数无默认值其余均有默认值的构造函数，还具有类型转换的作用。

class Date
{
public:
    //1.单参构造函数，没有使用explicit修饰，具有类型转换作用
    //explicit修饰构造函数，禁止类型转换---explicit去掉之后，代码可以通过编译
    explicit Date(int year)
            :_year(year)
            {}
    /*
    //2.虽然有多个参数，但是创建对象时后两个参数可以不传递，没有使用explicit修饰，具有类型转换作用
    //explicit修饰构造函数，禁止类型转换
    explicit Date(intyear,intmonth=1,intday=1)
    :_year(year),_month(month),_day(day)
    {}
    */
    Date& operator=(const Date& d)
    {
        if(this != &d)
        {
            _year=d._year;
            _month=d._month;
            _day=d._day;
        }
        return*this;
    }
private:
    int _year;
    int _month;
    int _day;
};

void Test()
{
    Date d1(2024);
//用一个整形变量给日期类型对象赋值
//实际编译器背后会用2023构造一个无名对象，最后用无名对象给d1对象进行赋值
    d1 = 1900;
//将1屏蔽掉，2放开时则编译失败，因为explicit修饰构造函数，禁止了单参构造函数类型转换的作用
}

用explicit修饰构造函数，将会禁止构造函数的隐式转换。

（2）Static成员

1.概念

声明为static的类成员称为类的静态成员，用static修饰的成员变量，称之为静态成员变量；用static修饰的成员函数，称之为静态成员函数。静态成员变量一定要在类外进行初始化。

question：实现一个类，计算程序中创建了多少个类对象？（对象由构造函数和拷贝构造产生）

#include <iostream>
using namespace std;

class A
{
public:
    A()
    {
        ++_n;
    }
    A(const A& t)
    {
        ++_n;
    }
    static int Getnum()
    {
        return _n;
    }
private:
    static int _n;
};

int A::_n = 0;

int main()
{
    cout << A::Getnum() << endl;
    A a1,a2;
    A a3(a1);
    cout << A::Getnum() << endl;

    system("pause");
    return 0;
}

运行结果：

2.特性：

1.static成员变量不存在对象中，存在静态区，属于这个类的所有对象，也是属于这个类。

2.static成员函数，没有this指针，不使用对象就可以调用。->类名::func();

3.static成员函数中，不能访问非静态的成员（成员变量+成员函数）

class Date
{
public:
    Date(int year = 0,int month = 1,int day = 1)
    :_year(year), _month(month), _day(day)
    {}

    // 1.静态成员函数可以调用非静态成员函数吗？ 不行
//    void f1()
//    {
//
//    }
//    static void f2()
//    {
//        f1(); // 没有this指针，要访问需要this指针
//    }

    // 2.非静态成员函数可以可以调用类的成员函数吗？ 可以
    void f3()
    {
        f4(); // 突破类域就可以访问，类里面是一个整体都在这类域中，类里面不受访问限定符的限制。
    }
    static void f4()
    {

    }

private:
    int _year;
    int _month;
    int _day;
};

question：

1.静态成员函数可以调用非静态成员函数吗？

Answer：在C++中，静态成员函数属于类本身，而非静态成员函数属于类的实例（对象）。因此，静态成员函数无法直接调用非静态成员函数，因此静态成员函数this指针，它不能访问类的实例数据。

2.非静态成员函数可以调用静态成员函数吗？

Answer：静态成员函数与类关联，而非静态成员函数则与类的实例（对象）有关。非静态成员函数在其执行上下文中持有一个this指针，通过该指针能够访问类的静态成员。

（3）友元

友元提供了一种突破封装的方式，又是提供了便利。但是友元会增加耦合度，破坏了封装，所以友元不宜多用。

友元分为：友元函数和友元类。

1.友元函数

现在我们先来重载“ << ”

#include <iostream>
using namespace std;

class Date
{
public:
    void Print()
    {
        cout << _year << '-' << _month << '-' << _day << endl;
    }

    void operator<<(ostream& out)
    {
        out << _year << "/" << _month << "/" << _day << endl;
    }

private:
    int _year = 0;
    int _month = 1;
    int _day = 1;
};

int main()
{
    Date d1;
    d1.Print();
    cout << d1;
//  d1.operator<<(cout);

    system("pause");
    return 0;
}

运行结果：（报错）

所以写成d1 << cout后运行结果为：（正常运行）

那么为什么会出现这种问题？因为cout的输出流对象和隐含的this指针在抢第一个参数的位置。this指针默认是第一个参数也就是左操作数了。但是实际使用中cout需要是第一个形参对象，才能正常使用。所以要将operator<<重载成全局函数。但又会导致类外没办法访问成员，此时就需要友元来解决。operator>>同理。

#include <iostream>
using namespace std;

class Date
{
    friend ostream& operator<<(ostream& _cout,const Date& d);
    friend istream& operator>>(istream& _cin,const Date& d);
public:
    Date(int year = 1900,int month = 1,int day = 1)
    : _year(year), _month(month), _day(day)
    {}
private:
    int _year;
    int _month;
    int _day;
};

ostream& operator<<(ostream& _cout,const Date& d)
{
    _cout << d._year << '-' << d._month << '-' << d._day << endl;
    return _cout;
}

istream& operator>>(istream& _cin,const Date& d)
{
    _cin >> d._year;
    _cin >> d._month;
    _cin >> d._day;
    return _cin;
}

int main()
{
    Date d;
    cin >> d;
    cout << d;
    return 0;
}

Note：

1.友元函数可访问类的私有和保护成员，但不是类的成员函数。

2.友元函数不能用const修饰。

3.友元函数可以在类定义的任何地方声明，不受类访问限定符的限制。

4.一个函数可以是多个类的友元函数。

5.友元函数的调用与普通函数的调用原理相同。

2.友元类

友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非共有成员。

  • 友元关系是单向的，不具有交换性。（比如上述Time类和Date类，在Time类中声明Date类为其友元类，那么可以在Date类中直接访问Time类的私有成员变量，但想在Time类中访问Date类中私有的成员变量则不行。）
  • 友元关系不能传递。（如果C是B的友元，B是A的友元，则不能说明C时A的友元。）
  • 友元关系不能继承，在继承的部分再详细介绍。
class Time
{
    friend class Date;// 声明日期类为时间类的友元类，则在日期类中就直接访问Time类中的私有成员变量
public:
    Time(int hour = 0,int minute = 0,int second = 0)
    : _hour(hour), _minute(minute), _second(second)
    {}
private:
    int _hour;
    int _minute;
    int _second;
};

class Date
{
public:
    Date(int year = 1900,int month = 1,int day = 1)
    : _year(year), _month(month), _day(day)
    {}

    void SetTimeOfDate(int hour,int minute,int second)
    {
        // 直接访问时间类私有的成员变量
        _t._hour = hour;
        _t._minute = minute;
        _t._second = second;
    }

private:
    int _year;
    int _month;
    int _day;

    Time _t;
};

（4）内部类

概念：如果一个类定义在另一个类的内部，这个类就叫做内部类。内部类是一个独立的类，它不属于外部类，更不能通过外部类的对象去访问内部类的成员。外部类对内部类没有任何优越的访问权限。

注意：内部类就是外部类的友元类，参见友元类的定义，内部类可以通过外部类的对象参数访问外部类中的所有成员。但是外部类不是内部类的友元。

特性：

  1. 内部类可以定义在外部类的public，protected，pravite都是可以的。
  2. 注意内部类可以直接访问外部类中的static成员，不需要外部类的对象/类名。
class A
{
public:
    class B // B天生就是A的友元
    {
    public:
        void f(const A& d)
        {
            cout << a << endl; // 内部类可以直接访问外部类中的static成员，不需要外部类的对象/类名.
            cout << d.b << endl;
        }
    };
private:
    static int a;
    int b;
};

int A::a = 1;

int main()
{
    A::B b;
    b.f(A());

    return 0;
}

 

（5）匿名对象

在C++中，匿名对象是指没有名称的对象。这类对象通常用于临时目的，常见的使用场景包括：

1.临时对象返回值：

当一个函数返回一个对象时，通常会生成一个匿名对象。

class Point {  
public:  
    Point(int x, int y) 
    : _x(x), _y(y) {}  
    void display() {  
        cout << "(" << _x << ", " << _y << ")" << endl;  
    }  
private:  
    int _x, _y;  
};  

Point createPoint() 
{  
    return Point(1, 2); // 返回匿名对象  
}  

int main() 
{  
    createPoint().display(); // 使用匿名对象调用display()  
    return 0;  
}

2.在表达式中使用：

可以在表达式中创建并使用匿名对象：

Point(3, 4).display(); // 临时创建一个Point对象并调用display()

3.构造函数的调用：

当你需要一个临时对象来调用某个函数时，可以直接使用匿名对象。

void processPoint(Point p) {  
    p.display();  
}  

int main() {  
    processPoint(Point(5, 6)); // 传递匿名对象  
    return 0;  
}

注意：

  • 生命周期：匿名对象的生命周期在表达式结束时会自动结束。当你创建一个匿名对象后，它会在使用完毕后被销毁，因此不能在超出其作用域的地方访问它。

  • 拷贝性能：由于匿名对象的产生和析构，频繁使用匿名对象可能会影响性能，尤其是在创建大型对象时。C++11的移动语义和完美转发可以帮助优化这些性能问题。

  • 使用场景：在某些情况下，使用匿名对象可以使代码更加简洁和直观，但也要注意可读性的问题，过多的匿名对象可能会导致代码难以理解。

（6）再次理解类和对象

现实生活中的实体计算机并不认识，计算机只认识二进制格式的数据。如果想要让计算机认识现
实生活中的实体，用户必须通过某种面向对象的语言，对实体进行描述，然后通过编写程序，创
建对象后计算机才可以认识。比如想要让计算机认识洗衣机，就需要：
1.用户先要对现实中洗衣机实体进行抽象---即在人为思想层面对洗衣机进行认识，洗衣机有什么属性，有那些功能，即对洗衣机进行抽象认知的一个过程。
2.经过1之后，在人的头脑中已经对洗衣机有了一个清醒的认识，只不过此时计算机还不清楚，想要让计算机识别人想象中的洗衣机，就需要人通过某种面相对象的语言(比如：C++、Java、Python等)将洗衣机用类来进行描述，并输入到计算机中。
3.经过2之后，在计算机中就有了一个洗衣机类，但是洗衣机类只是站在计算机的角度对洗机对象进行描述的，通过洗衣机类，可以实例化出一个个具体的洗衣机对象，此时计算机才能洗衣机是什么东西。
4.用户就可以借助计算机中洗衣机对象，来模拟现实中的洗衣机实体了。
在类和对象阶段，大家一定要体会到，类是对某一类实体(对象)来进行描述的，描述该对象具有哪些属性，那些方法，描述完成后就形成了一种新的自定义类型，才用该自定义类型就可以实例化具体的对象。

标签：对象,成员,C++,month,int,彼岸花,year,day
From： https://blog.csdn.net/2401_86606773/article/details/141104768

相关文章

  • Python面向对象设计的一些重要概念
     对象:对象由属性和方法组成。属性不过是属于对象的变量，而方法是存储在属性中的函数。相比于其他函数，(关联的)方法有一个不同之处，那就是它总是将其所属的对象作为第一个参数，而这个参数通常被命名为self。类:类表示一组(或一类)对象，而每个对象都属于特定的类。类的主要任务是定......
  • C++-练习-16
    题目：编写一个程序，它要求用户输入其名，然后输入其姓。然后程序使用一个逗号和空格将姓和名组合起来，并存储和显示结果。请使用char数组和头文件cstring(string.h)中的函数。源代码：#define_CRT_SECURE_NO_WARNINGS //vs版本不加这个无法使用strcat等函数#include<iostream>#......
  • C++-练习-17
    题目：结构CandyBar包含3个成员，第一个成员存储了糖块的品牌；第二个成员存储糖块的重量（可以有小数）；第三个成员存储了糖块的卡路里含量（整数）。请编写一个程序，要声明这个结构，创建一个名为sncak的CandyBar变量，并将其成员分别初始化为“MochaMunch”,2.3和350。初始化应在声明snack时进......
  • 虚化引擎 C++基础 2 C++游戏架构，创建默认的c++类
    游戏模式一、游戏模式重载（GameModeOverride）：设置游戏的基础玩法，包含玩家数量，关卡过度，玩家进入游戏方式等。二、默认Pawn类（DefaultPawnClass）：玩家的默认角色，可以是带有复杂运动系统的character也可以是简单运动的Pawn。########Pawn和Character的区别：Pawn和Character的区别：P......
  • c++ 线程函数传递数据 namespace
     CMakeLists.txt cmake_minimum_required(VERSION3.10)#Settheprojectnameproject(GlobalMatrixExample)#FindEigenpackagefind_package(Eigen33.3REQUIRED)#Findpthreadpackagefind_package(ThreadsREQUIRED)#Addexecutableadd_executable(g......
  • 【C++】类与对象（中）_7.const成员函数
    7.const成员7.1const修饰类的成员函数将const修饰的类成员函数称之为const成员函数，const修饰类成员函数，实际修饰该成员函数隐含的this指针，表明在该成员函数中不能对类的任何成员进行修改。我们来看看下面的代码#define_CRT_SECURE_NO_WARNINGS1#include<iostream>......
  • 虚幻引擎5 C++基础 C++各类宏的作用
    1.GENERATED_BODY()//自动生成的宏，不直接使用父类的构造函数，如果需要做初始化操作，需要在自己的.h头文件中声明构造函数。在Cpp文件中实现，同时是private。//GENERATED_UCLASS_BODY()，使用父类的构造函数，进行初始化操作不需要.h文件中声明，可以直接在CPP文件中实现构造函数。//UPROP......
  • C++ 适配器 stack
    不了解适配器的读者可以先去看一看这一篇博客：C++适配器-CSDN博客栈数据结构介绍我们平时洗碗的时候，叠成一层层的碗最后只能从上面往下面开始拿；平时箱子里面叠的衣服，也是只能从上面慢慢拿。先放进去的东西后拿出来，这种内存特点的数据结构就叫栈。就像一个只有单边口的容器......
  • 19. 面向对象编程
    1.面向对象编程引入1.0分析属性做一款人狗大战的小游戏 人的属性：人的姓名人的性别人的年龄人的生命值人的攻击力 狗的属性：狗的名字狗的年龄狗的生命值狗的攻击力狗的品种1.1方式一：面条版使用字典定义属性#......
  • 类和对象 封装 private this关键句
    publicclass类名{1.成员变量（代表属性，一般是名词）2.成员方法（代表行为，一般是动词）3.构造器4.代码块5.内部类}类：是共同特征的描述（设计图）；对象：是真实存在的具体实例用来描述一类事物的类，专业叫做Javabean类（在JavaBean中是不写main方法的）以前编写的main方法的类叫做测试类（......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99