类和对象基础（2）

于 2024-10-06 23:42:25 发布
阅读量1.2k 收藏 29
点赞数 33
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_84107961/article/details/142731632
版权

1.构造函数

构造函数是特殊的成员函数，需要注意的是，构造函数虽然名称叫构造，但是构造函数的主要任务并不是开空间创建对象(我们常使⽤的局部对象是栈帧创建时，空间就开好了)，⽽是对象实例化时初始化对象。
构造函数的特点：
  1. 函数名与类名相同。
  2. 无返回值。
  3. 对象实例化时系统会自动调用对应的构造函数。
  4. 编译器默认生成的构造，对内置类型成员变量的初始化没有要求，也就是说是是否初始
    化是不确定的，看编译器。对于⾃定义类型成员变量，要求调用这个成员变量的默认构造函数初始化。
  5. 无参构造函数、全缺省构造函数、我们不写构造时编译器默认生成的构造函数，都叫做默认构造函数。但是这三个函数有且只有⼀个存在，不能同时存在。无参构造函数和全缺省构造函数虽然构成函数重载，但是调用时会存在歧义。
  6. 如果类中没有显式定义构造函数，则C++编译器会自动⽣成⼀个无参的默认构造函数，⼀旦用户显式定义编译器将不再⽣成。
  7. 构造函数可以重载。

 说明：C++把类型分成内置类型(基本类型)和自定义类型。内置类型就是语言提供的原生数据类型，如：int/char/double/指针等，自定义类型就是我们使用class/struct等关键字自己定义的类型。 

#include<iostream>
using namespace std;
class Date
{
public:
// 1.⽆参构造函数
  Date()
  {
     _year;
     _month;
     _day;
  }
// 2.带参构造函数
  Date(int year,int month,int day)
  {
     _year=year;
     _month=month;
     _day=day;
  }
// 3.全缺省构造函数
  Date(int year=1,int month=1,int day=1)
  {
     _year=year;
     _month=month;
     _day=day;
  }
void Print()
  {
     cout << _year << "/" << _month << "/" << _day << endl;
  }
private:
  int _year;
  int _month;
  int _day;
};
int main()
{
// 如果留下三个构造中的第⼆个带参构造，第⼀个和第三个注释掉
// 编译报错：error C2512: “Date”: 没有合适的默认构造函数可⽤
  Date d1; // 调⽤默认构造函数
  Date d2(2025, 1, 1); // 调⽤带参的构造函数
// 注意：如果通过⽆参构造函数创建对象时，对象后⾯不⽤跟括号，否则编译器⽆法
// 区分这⾥是函数声明还是实例化对象

// warning C4930: “Date d3(void)”: 未调⽤原型函数(是否是有意⽤变量定义的?)
// Date d3();
  Data d3;

  d1.Print();
  d2.Print();
  d3.Print();
  return 0;
}

2.析构函数

析构函数与构造函数功能相反，析构函数不是完成对对象本身的销毁，比如局部对象是存在栈帧的，函数结束栈帧销毁，他就释放了，不需要我们管，C++规定对象在销毁时会⾃动调⽤析构函数，完成对象中资源的清理释放⼯作。
析构函数的特点：
  1. 析构函数名是在类名前加上字符 ~。
  2. ⽆参数⽆返回值。 (这里跟构造类似，也不需要加void)。
  3. ⼀个类只能有⼀个析构函数。若未显式定义，系统会自动生成默认的析构函数。
  4. 对象生命周期结束时，系统会自动调用析构函数。
  5. 如果类中没有申请资源时，析构函数可以不写，直接使用编译器⽣成的默认析构函数。
    但是有资源申请时，⼀定要自己写析构，否则会造成资源泄漏。
    如果默认生成的析构就可以用，也就不需要显示写析构。
  6. 跟构造函数类似，我们不写编译器自动生成的析构函数对内置类型成员不做处理，自定类型成员会调用他的析构函数。
  7. 还需要注意的是我们显示写析构函数，对于自定义类型成员也会调用他的析构，也就是说自定义类型成员无论什么情况都会自动调用析构函数。
  8. ⼀个局部域的多个对象，C++规定后定义的先析构。

    3.拷贝构造函数

    如果⼀个构造函数的第⼀个参数是自身类类型的引用，且任何额外的参数都有默认值，则此构造函数也叫做拷贝构造函数，也就是说拷贝构造是⼀个特殊的构造函数。
    拷贝构造的特点：
    1. 拷贝构造函数是构造函数的⼀个重载。
    2. 拷贝构造函数的第⼀个参数必须是类类型对象的引用，使用传值方式编译器直接报错，因为语法逻辑上会引发⽆穷递归调用。 拷贝构造函数也可以多个参数，但是第⼀个参数必须是类类型对象的引用，后⾯的参数必须有缺省值。​​​​​​
    3. 传值返回会产⽣⼀个临时对象调⽤拷⻉构造，传值引⽤返回，返回的是返回对象的别名(引⽤)，没有产⽣拷⻉。但是如果返回对象是⼀个当前函数局部域的局部对象，函数结束就销毁了，那么使⽤引⽤返回是有问题的，这时的引⽤相当于⼀个野引⽤，类似⼀个野指针⼀样。传引⽤返回可以减少拷⻉，但是⼀定要确保返回对象，在当前函数结束后还在，才能⽤引⽤返回。
    4. 若未显式定义拷贝构造，编译器会生成自动生成拷贝构造函数。自动生成的拷贝构造对内置类型成员变量会完成值拷贝/浅拷贝(⼀个字节⼀个字节的拷贝)，对自定义类型成员变量会调用他的拷贝构造。
    5. C++规定自定义类型对象进行拷贝行为必须调用拷贝构造，所以这里自定义类型传值传参和传值返回都会调用拷贝构造完成。
      # include <iostream>
      using namespace std;
      class Date
      {
      public :
      Date ( int year = 1 , int month = 1 , int day = 1 )
      {
      _year = year;
      _month = month;
      _day = day;
      }
      Date (Date* d)
      {
      _year = d->_year;
      _month = d->_month;
      _day = d->_day;
      }
        // 编译报错： error C2652: “Date”: ⾮法的复制构造函数 : 第⼀个参数不应是 “Date”
      //Date(Date d)
      Date ( const Date& d)
      {
      _year = d._year;
      _month = d._month;
      _day = d._day;
      }
      private :
      int _year;
      int _month;
      int _day;
      };
      int main()
      {
      Date d1;
      Date d2 (&d1); // 这⾥可以完成拷⻉，但是不是拷⻉构造，只是⼀个普通的构造
      Date d3(d1); // 这样写才是拷⻉构造，通过同类型的对象初始化构造，⽽不是指针
      //Date d3 = d1;   也可以这样写，这⾥也是拷⻉构造
      return 0;
      } 

4.赋值运算符重载 

4.1运算符重载

  • 当运算符被⽤于类类型的对象时，C++语⾔允许我们通过运算符重载的形式指定新的含义。C++规定类类型对象使⽤运算符时，必须转换成调⽤对应运算符重载，若没有对应的运算符重载，则会编译报错。
  • 重载运算符函数的参数个数和该运算符作⽤的运算对象数量⼀样多。⼀元运算符有⼀个参数，⼆元运算符有两个参数，⼆元运算符的左侧运算对象传给第⼀个参数，右侧运算对象传给第⼆个参数。
  • 如果⼀个重载运算符函数是成员函数，则它的第⼀个运算对象默认传给隐式的this指针，因此运算 符重载作为成员函数时，参数⽐运算对象少⼀个。
  • 运算符重载是具有特殊名字的函数，他的名字是由operator和后⾯要定义的运算符共同构成。和其 他函数⼀样，它也具有其返回类型和参数列表以及函数体。
  • 重载++运算符时，有前置++和后置++，运算符重载函数名都是operator++，⽆法很好的区分。C++规定，后置++重载时，增加⼀个int形参，跟前置++构成函数重载，⽅便区分。
  • .*  ::  sizeof   ?:    . 注意以上5个运算符不能重载。
  • 不能通过连接语法中没有的符号来创建新的操作符：⽐如operator@。
  • 运算符重载以后，其优先级和结合性与对应的内置类型运算符保持⼀致。
  • 重载<<和>>时，需要重载为全局函数，因为重载为成员函数，this指针默认抢占了第⼀个形参位置，第⼀个形参位置是左侧运算对象，调⽤时就变成了 对象<<cout，不符合使⽤习惯和可读性。重载为全局函数把ostream/istream放到第⼀个形参位置就可以了，第⼆个形参位置当类类型对象。
    class Date
    {
        //operator 在类内，那么第一个传参给this
        bool operator == (Date d2)
       {
           return _year == d2._year
               && _month == d2._month
               && _day == d2._day;
       {
     
    };
     
    int main()
    {
        Date x1(1,1,1);
        Date x2(2,2,2);
        
        x1.operator == (x2);
        //相当于
        x1 == x2;
     
        return 0;
    }

前置++后置++重载

前置++：返回+1之后的结果

class Date
{
public:
 Date(int year = 1900, int month = 1, int day = 1)

{
 _year = year;
 _month = month;
 _day = day;
}
 
 Date& operator++()
{
 _day += 1;
 return *this;
}
 
private:
 int _year;
 int _month;
 int _day;
};

C++规定后置++重载时多增加一个int类型的参数，但调用函数时该参数不用传递，编译器
自动传递 

 后置++：后置++是先使用后+1，因此需要返回+1之前的旧值

class Date
{
public:
 Date(int year = 1900, int month = 1, int day = 1)
{
 _year = year;
 _month = month;
 _day = day;
}
 
 Date& operator++()
{
 _day += 1;
 return *this;
}
 
private:
 int _year;
 int _month;
 int _day;
};

4.2赋值运算符重载

赋值运算符重载是⼀个默认成员函数，⽤于完成两个已经存在的对象直接的拷⻉赋值，这⾥要注意跟拷⻉构造区分，拷⻉构造⽤于⼀个对象拷⻉初始化给另⼀个要创建的对象。

赋值运算符重载的特点：

  1. 赋值运算符重载是⼀个运算符重载，规定必须重载为成员函数。赋值运算重载的参数建议写成const当前类类型引⽤，否则会传值传参会有拷⻉。
  2. 有返回值，且建议写成当前类类型引⽤，引⽤返回可以提⾼效率，有返回值⽬的是为了⽀持连续赋值场景。
  3. 没有显式实现时，编译器会⾃动⽣成⼀个默认赋值运算符重载，默认赋值运算符重载⾏为跟默认拷⻉构造函数类似，对内置类型成员变量会完成值拷⻉/浅拷⻉(⼀个字节⼀个字节的拷⻉)，对⾃定义类型成员变量会调⽤他的赋值重载函数。
  4. 成员变量全是内置类型且没有指向什么资源，编译器⾃动⽣成的赋值运算符重载就可以完成需要的拷⻉，所以不需要我们显⽰实现赋值运算符重载。
    有指向了资源的，编译器⾃动⽣成的赋值运算符重载完成的值拷⻉/浅拷⻉不符合我们的需求，所以需要我们⾃⼰实现深拷⻉(对指向的资源也进⾏拷⻉)。
    类型内部是已经实现了的自定义成员，编译器⾃动⽣成的赋值运算符重载会调⽤自定义成员的赋值运算符重载。
class Date
{
public :
Date ( int year = 1 , int month = 1 , int day = 1 )
{
_year = year;
_month = month;
_day = day;
}
Date ( const Date& d)
{
cout << " Date(const Date& d)" << endl;
_year = d._year;
_month = d._month;
_day = d._day;
}
// 传引⽤返回减少拷⻉
// d1 = d2;
Date& operator =( const Date& d)
{
// 检查是否自己给自己拷贝
if ( this != &d)
{
_year = d._year;
_month = d._month;
_day = d._day;
}
// d1 = d2 表达式的返回对象应该为 d1 ，也就是 *this
return * this ;
}
void Print ()
{
cout << _year << "-" << _month << "-" << _day << endl;
}
private :
int _year;
int _month;
int _day;
};
int main ()
{
Date d1 ( 2024 , 7 , 5 );
Date d2 (d1);
Date d3 ( 2024 , 7 , 6 );
d1 = d3; 
// 需要注意这⾥是拷⻉构造，不是赋值重载
// 请牢牢记住赋值重载完成两个已经存在的对象直接的拷⻉赋值
// ⽽拷⻉构造⽤于⼀个对象拷⻉初始化给另⼀个要创建的对象
Date d4 = d1;
return 0 ;
}

4.3日期类实现

//需要用到友元函数，后面会提到

Date.h

# pragma once
# include <iostream>
using namespace std;
# include <assert.h>
class Date
{
// 友元函数声明
friend ostream& operator <<(ostream& out, const Date& d);
friend istream& operator >>(istream& in, Date& d);
public :
Date ( int year = 1900 , int month = 1 , int day = 1 );
void Print () const ;
// 直接定义类⾥⾯，他默认是 inline
// 频繁调⽤
int GetMonthDay ( int year, int month)
{
assert (month > 0 && month < 13 );
static int monthDayArray[ 13 ] = { -1 , 31 , 28 , 31 , 30 , 31 , 30 ,
31 , 31 , 30 , 31 , 30 , 31 };
// 365 天 5h +
if (month == 2 && (year % 4 == 0 && year % 100 != 0 ) || (year
% 400 == 0 ))
{
return 29 ;
}
else
{
return monthDayArray[month];
}
}
bool CheckDate ();
bool operator <( const Date& d) const ;
bool operator <=( const Date& d) const ;
bool operator >( const Date& d) const ;
bool operator >=( const Date& d) const ;
bool operator ==( const Date& d) const ;
bool operator !=( const Date& d) const ;
// d1 += 天数
Date& operator +=( int day);
Date operator +( int day) const ;
// d1 -= 天数
Date& operator -=( int day);
Date operator -( int day) const ;
// d1 - d2
int operator -( const Date& d) const ;
// ++d1 -> d1.operator++()
Date& operator ++();
// d1++ -> d1.operator++(0)
// 为了区分，构成重载，给后置 ++ ，强⾏增加了⼀个 int 形参
// 这⾥不需要写形参名，因为接收值是多少不重要，也不需要⽤
// 这个参数仅仅是为了跟前置 ++ 构成重载区分
Date operator ++( int );
Date& operator --();
Date operator --( int );
// 流插⼊
// 不建议，因为 Date* this 占据了⼀个参数位置，使⽤ d<<cout 不符合习惯
//void operator<<(ostream& out);
private :
int _year;
int _month;
int _day;
};
// 重载
ostream& operator <<(ostream& out, const Date& d);
istream& operator >>(istream& in, Date& d);

Date.cpp

# include "Date.h"
bool Date::CheckDate ()
{
if (_month < 1 || _month > 12
|| _day < 1 || _day > GetMonthDay (_year, _month))
{
return false ;
}
else
{
return true ;
}
}
Date:: Date ( int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
if (! CheckDate ())
{
cout << " ⽇期⾮法 " << endl;
}
}
void Date::Print () const
{
cout << _year << "-" << _month << "-" << _day << endl;
}
// d1 < d2
bool Date:: operator <( const Date& d) const
{
if (_year < d._year)
{
return true ;
}
else if (_year == d._year)
{
if (_month < d._month)
{
return true ;
}
else if (_month == d._month)
{
return _day < d._day;
}
}
return false ;
}
// d1 <= d2
bool Date:: operator <=( const Date& d) const
{
return * this < d || * this == d;
}
bool Date:: operator >( const Date& d) const
{
return !(* this <= d);
}
bool Date:: operator >=( const Date& d) const
{
return !(* this < d);
}
bool Date:: operator ==( const Date& d) const
{
return _year == d._year
&& _month == d._month
&& _day == d._day;
}
bool Date:: operator !=( const Date& d) const
{
return !(* this == d);
}
// d1 += 50
// d1 += -50
Date& Date:: operator +=( int day)
{
if (day < 0 )
{
return * this -= -day;
}
_day += day;
while (_day > GetMonthDay (_year, _month))
{
_day -= GetMonthDay (_year, _month);
++_month;
if (_month == 13 )
{
++_year;
_month = 1 ;
}
}
return * this ;
}
Date Date:: operator +( int day) const
{
Date tmp = * this ;
tmp += day;
return tmp;
}
// d1 -= 100
Date& Date:: operator -=( int day)
{
if (day < 0 )
{
return * this += -day;
}
_day -= day;
while (_day <= 0 )
{
--_month;
if (_month == 0 )
{
_month = 12 ;
_year--;
}
// 借上⼀个⽉的天数
_day += GetMonthDay (_year, _month);
}
return * this ;
}
Date Date:: operator -( int day) const
{
Date tmp = * this ;
tmp -= day;
return tmp;
}
//++d1
Date& Date:: operator ++()
{
* this += 1 ;
return * this ;
}
// d1++
Date Date:: operator ++( int )
{
Date tmp (* this );
* this += 1 ;
return tmp;
}
Date& Date:: operator --()
{
* this -= 1 ;
return * this ;
}
Date Date:: operator --( int )
{
Date tmp = * this ;
* this -= 1 ;
return tmp;
}
// d1 - d2
int Date:: operator -( const Date& d) const
{
Date max = * this ;
Date min = d;
int flag = 1 ;
if (* this < d)
{
max = d;
min = * this ;
flag = -1 ;
}
int n = 0 ;
while (min != max)
{
++min;
++n;
}
return n * flag;
}
ostream& operator <<(ostream& out, const Date& d)
{
out << d._year << " 年 " << d._month << " ⽉ " << d._day << " ⽇ " << endl;
return out;
}
istream& operator >>(istream& in, Date& d)
{
cout << " 请依次输⼊年⽉⽇ :>" ;
in >> d._year >> d._month >> d._day;
if (!d. CheckDate ())
{
cout << " ⽇期⾮法 " << endl;
}
return in;
}

 

 Test.cpp

# include "Date.h"
void TestDate1 ()
{
// 这⾥需要测试⼀下⼤的数据 + 和 -
Date d1 ( 2024 , 4 , 14 );
Date d2 = d1 + 30000 ;
d1. Print ();
d2. Print ();
Date d3 ( 2024 , 4 , 14 );
Date d4 = d3 - 5000 ;
d3. Print ();
d4. Print ();
Date d5 ( 2024 , 4 , 14 );
d5 += -5000 ;
d5. Print ();
}
void TestDate2 ()
{
Date d1 ( 2024 , 4 , 14 );
Date d2 = ++d1;
d1. Print ();
d2. Print ();
Date d3 = d1++;
d1. Print ();
d3. Print ();
/*d1.operator++(1);
d1.operator++(100);
d1.operator++(0);
d1.Print();*/
}
void TestDate3 ()
{
Date d1 ( 2024 , 4 , 14 );
Date d2 ( 2034 , 4 , 14 );
int n = d1 - d2;

 

cout << n << endl;
n = d2 - d1;
}
void TestDate4 ()
{
Date d1 ( 2024 , 4 , 14 );
Date d2 = d1 + 30000 ;
// operator<<(cout, d1)
cout << d1;
cout << d2;
cin >> d1 >> d2;
cout << d1 << d2;
}
void TestDate5 ()
{
const Date d1 ( 2024 , 4 , 14 );
d1. Print ();
//d1 += 100;
d1 + 100 ;
Date d2 ( 2024 , 4 , 25 );
d2. Print ();
d2 += 100 ;
d1 < d2;
d2 < d1;
}
int main ()
{
return 0 ;
}

5.取地址运算符重载 

5.1const成员函数

  • 将const修饰的成员函数称之为const成员函数，const修饰成员函数放到成员函数参数列表的后⾯。
  • const实际修饰该成员函数隐含的this指针，表明在该成员函数中不能对类的任何成员进⾏修改。const 修饰Date类的Print成员函数，Print隐含的this指针由 Date* const this 变为 const
    Date* const this。
# include <iostream>
using namespace std;
class Date
{
public :
Date ( int year = 1 , int month = 1 , int day = 1 )
{
_year = year;
_month = month;
_day = day;
}
// void Print(const Date* const this) const
void Print () const
{
cout << _year << "-" << _month << "-" << _day << endl;
}
private :
int _year;
int _month;
int _day;
};

5.2取地址运算符重载

取地址运算符重载分为普通取地址运算符重载和const取地址运算符重载，⼀般这两个函数编译器⾃动⽣成的就可以够我们⽤了，不需要去显⽰实现。

class Date
{
public:
    Date* operator&()
    {
        return this;
    }
    const Date* operator&()const
    {
        return this;
    }
private:
    int _year; // 年
    int _month; // 月
    int _day; // 日
}; 

小跌—
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值