vs2010如何做网站,建设通网站是什么性质,如何建立一个免费的网站,辽宁省城乡住房和建设厅网站类的6个默认成员函数 如果一个类中什么成员都没有#xff0c;简称为空类。 空类中真的什么都没有吗#xff1f;并不是#xff0c;任何类在什么都不写时#xff0c;编译器会自动生成以下 6 个默认成员函数。默认成员函数#xff1a;用户没有显式实现#xff0c;编译器会生…类的6个默认成员函数 如果一个类中什么成员都没有简称为空类。 空类中真的什么都没有吗并不是任何类在什么都不写时编译器会自动生成以下 6 个默认成员函数。默认成员函数用户没有显式实现编译器会生成的成员函数称为默认成员函数。 这六个默认成员函数用户不写编译器会自动生成下边我来一一讲解 构造函数 对于以下Date类 class Date
{
public:void Init(int year, int month, int day){
_year year;_month month;_day day;}void Print(){cout _year - _month - _day endl;}
private:int _year;int _month;int _day;
};
int main()
{Date d1;d1.Init(2022, 7, 5);d1.Print();Date d2;d2.Init(2022, 7, 6);d2.Print();return 0;
} 对于 Date 类可以通过 Init 公有方法给对象设置日期但如果每次创建对象时都调用该方法设置信息未免有点麻烦那能否在对象创建时就将信息设置进去呢 构造函数 是一个 特殊的成员函数名字与类名相同 , 创建类类型对象时由编译器自动调用 以保证每个数据成员都有 一个合适的初始值并且在对象整个生命周期内只调用一次 。 特性 class Date{public:// 1.无参构造函数Date(){}// 2.带参构造函数Date(int year, int month, int day){_year year;_month month;_day day;}private:int _year;int _month;int _day;};void TestDate(){Date d1; // 调用无参构造函数Date d2(2015, 1, 1); // 调用带参的构造函数// 注意如果通过无参构造函数创建对象时对象后面不用跟括号否则就成了函数声明// 以下代码的函数声明了d3函数该函数无参返回一个日期类型的对象// warning C4930: “Date d3(void)”: 未调用原型函数(是否是有意用变量定义的?)Date d3();} 注意无参的对象调用无参构造函数传参的对象调用带参构造函数 如果类中没有显式定义构造函数则 C 编译器会自动生成一个无参的默认构造函数一旦 用户显式定义编译器将不再生成。 class Date{public:/*// 如果用户显式定义了构造函数编译器将不再生成Date(int year, int month, int day){_year year;_month month;_day day;}*/void Print(){cout _year - _month - _day endl;}private:int _year;int _month;int _day;};int main(){Date d1;return 0;} 如果没有显示写构造函数编译器默认生成一个无参构造函数不会报错原因等会我会总结 关于编译器生成的默认成员函数很多童鞋会有疑惑不实现构造函数的情况下编译器会 生成默认的构造函数。但是看起来默认构造函数又没什么用 d 对象调用了编译器生成的默 认构造函数但是 d 对象 _year/_month/_day 依旧是随机值。也就说在这里 编译器生成的 默认构造函数并没有什么用 解答 C 把类型分成内置类型 ( 基本类型 ) 和自定义类型。内置类型就是语言提供的数据类 型如 int/char... 自定义类型就是我们使用 class/struct/union 等自己定义的类型看看 下面的程序就会发现编译器生成默认的构造函数会对自定类型成员 _t 调用的它的默认成员 函数。 class Stack
{
public:private:int* _a;int _capacity;int _top;
};// 两个栈实现一个队列
class MyQueue
{
private:Stack _pushst;Stack _popst;int _size 1;
};int main()
{Stack st1;MyQueue mq;return 0;
} 看上面这段代码会是什么样的结果呢 可以看到内置类型没有被处理size用的是c11的缺省值没写缺省值也是随机值mq被处理了是vs2022的版本太高了用vs2013测试内置类型还是随机值所以我们认为内置类型不做处理 、 如果栈的构造函数我们写了看一下会发生什么 可以看到成功调用我们写的构造函数栈的内置类型和mq的自定义类型都被初始化了 得出一个结论我们不写编译器会生成一个默认成员函数内置成员不做处理自定义类型会去调用它的默认构造 c11打了一个补丁支持声明时给缺省值当我们没写内置类型会默认用缺省值 一般情况下我们都要自己写构造函数当成员都是自定义类型或者声明时给了缺省值可以考虑让编译器自己生成构造函数 1、我们不写编译默认生成那个构造函数叫默认构造
2、无参构造函数也可以叫默认构造
3、全缺省也可以叫默认构造
可以不传参数就调用构造都可以叫默认构造 这三个函数不能同时存在只能存在一个 class Date
{
public:Date(){_year 1900;_month 1;_day 1;}Date(int year 1900, int month 1, int day 1){_year year;_month month;_day day;}
private:int _year;int _month;int _day;
};
// 以下测试函数能通过编译吗
void Test()
{Date d1;
} 会报错调用不明确验证了只能有一个默认构造函数 析构函数 class Date
{
public:Date(int year 1, int month 1, int day 1){_year year;_month month;_day day;}void Print(){cout _year - _month - _day endl;}~Date(){// Date严格来说不需要写析构函数cout ~Date() endl;}
private:// C11支持声明时给缺省值int _year 1;int _month 1;int _day 1;
};class Stack
{
public:Stack(size_t capacity 3){cout Stack(size_t capacity 3) endl;_a (int*)malloc(sizeof(int) * capacity);if (nullptr _a){perror(malloc申请空间失败!!!);}_capacity capacity;_top 0;}~Stack(){cout ~Stack() endl;free(_a);_capacity _top 0;_a nullptr;}private:int* _a;int _capacity;int _top;
};class MyQueue
{private:Stack _pushst;Stack _popst;int _size 1;
};// 21:17继续
int main()
{Date d1;Stack st1;MyQueue mq;return 0;
}可以看到三次构造4次析构 说明析构函数原理和构造函数相似内置类型成员不做处理自定义类型成员会调用他的析构并且Date类的析构可写可不写不写和写的效果一样但是stack这种必须写编译器默认生成的并不会帮我们释放堆区空间会造成内存泄漏 拷贝构造函数 特征 拷贝构造函数也是特殊的成员函数其 特征 如下 1. 拷贝构造函数 是构造函数的一个重载形式 2. 拷贝构造函数的 参数只有一个 且 必须是类类型对象的引用 使用 传值方式编译器直接报错 因为会引发无穷递归调用。 class Date
{
public:Date(int year 1900, int month 1, int day 1){_year year;_month month;_day day;}// Date(const 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);return 0;
} 如果拷贝构造形参没有会造成无穷拷贝一定要加上引用 像上边这种代码是纯粹内置类型我们不写编译器默认生成的也会完成值拷贝所以这种类型全是内置类型的不用写构造函数也能完成任务 下边我用代码来解释原理 #includeiostream
using namespace std;
class Stack
{
public:Stack(size_t capacity 3){cout Stack(size_t capacity 3) endl;_a (int*)malloc(sizeof(int) * capacity);if (nullptr _a){perror(malloc申请空间失败!!!);}_capacity capacity;_top 0;}// Stack st2(st1);Stack(const Stack stt){cout Stack(Stack stt) endl;// 深拷贝_a (int*)malloc(sizeof(int) * stt._capacity);if (_a nullptr){perror(malloc fail);exit(-1);}memcpy(_a, stt._a, sizeof(int) * stt._top);_top stt._top;_capacity stt._capacity;}~Stack(){cout ~Stack() endl;free(_a);_capacity _top 0;_a nullptr;}private:int* _a;int _capacity;int _top;
};class MyQueue
{Stack _pushst;Stack _popst;int _size 0;
};int main()
{Stack st1;Stack st2(st1);MyQueue q1;MyQueue q2(q1);return 0;
} 可以看到我们写了stack的构造和拷贝构造结果st1和st2完成了构造和拷贝构造的任务并且st1拷贝st2是深拷贝_a新开辟了一块堆区空间 问题来了为什么要写拷贝构造呢因为不写默认生成的拷贝构造只能完成值拷贝就像刚才Date类一样只能完成内置类型值拷贝自定义类型如果也是值拷贝会造成同一块空间析构两次因为是两个对象作用域结束都会销毁两个对象析构2次所以是错误的我们要针对栈类写一个拷贝构造目的是完成深拷贝 再来看两个栈实现一个队列的q1,q2可以看到内置类型不做处理我们认为内置类型不做处理有些编译器会处理为0但还是建议认为内置不做处理更好理解规则自定义类型又去调用它的拷贝构造 总结 Date 和 MyQueue 默认生成拷贝就可以用 1、内置类型成员完成值拷贝 2、自定义类型成员调用这个成员的拷贝构造 Stack需要自己写拷贝构造完成深拷贝。 顺序表、链表、二叉树等等的类都需要深拷贝使用堆区空间的都需要深拷贝 赋值运算符重载 运算符重载不是赋值重载也不是默认成员函数不写编译器不会默认生成需要我们自己实现默认实现成operator // 运算符重载
class Date
{
public: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;
};bool operator(const Date x, const Date y)
{if (x._year y._year){return true;}else if (x._year y._year x._month y._month){return true;}else if (x._year y._year x._month y._month x._day y._day){return true;}return false;
}
bool operator(const Date x, const Date y)
{return x._year y._year x._month y._month x._day y._day;
}int main()
{Date d1;Date d2(2025, 10, 22);d1 d2;d1 d2;// 11:40 继续bool ret1 d1 d2; // operator(d1, d2);//编译器会转换成这个bool ret2 d1 d2; // operator(d1, d2);/*int x 1, y 2;bool ret1 x y;bool ret2 x y;*/return 0;
} 上边将运算符重载函数实现为全局的如果没有友元需要将私有去掉才能访问私有内置类型 为什么会有运算符重载呢因为我们要比较的时候内置类型是简单类型可以直接用各种运算符语言自己定义编译直接转换成指令但自定义类型是复杂类型不支持需要我们自己实现 赋值运算符重载 1. 赋值运算符重载格式 参数类型 const T 传递引用可以提高传参效率 返回值类型 T 返回引用可以提高返回的效率有返回值目的是为了支持连续赋值 检测是否自己给自己赋值 返回 *this 要复合连续赋值的含义 class Date
{
public:Date(int year 1900, int month 1, int day 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;
};int main()
{Date d1;Date d2(2025, 1, 1);d2d1;return 0;
} 可以看到赋值运算符重载对于内置类型可以实现也可以不实现结果是一样的 赋值运算符只能重载成类的成员函数不能重载成全局函数记住就行本来就是在类里边实现的 用户没有显式实现时编译器会生成一个默认赋值运算符重载以值的方式逐字节拷贝 。 注 意内置类型成员变量是直接赋值的而自定义类型成员变量需要调用对应类的赋值运算符 重载完成赋值。这个赋值重载和拷贝构造的意义可以类比理解都是内置类型不用处理自定义类型会调用它的复制拷贝也就是说有深拷贝的地方就要自己实现新的赋值拷贝从而防止析构两次和拷贝构造一个原理 日期类的实现
我把日期类原理给讲一下然后把代码整这上边想看了可以看看 这是简单的求日期天数当输入非法日期会打印日期非法 打印日期很简单 运算符重载年月日都相等会返回True this是d1的地址*this是d1返回比较的真假 比较大小先比较年年大即大年相等比较月月大即大年月都相等比较日日大即大其他情况都是不符合条件返回错误 这三个都比较简单就不赘述了 得到天数最好写成一个函数方便得到天数也就是已知年和月要得到日 直接构造一个tmp直接复用后返回tmp因为不会改变自身所以不返回*this 可以直接写的逻辑然后返回*this因为自身会修改day0复用-逻辑 -和-和是一个逻辑就不赘述了 注意如果返回自身*this并且返回值加引用是因为出了作用域自定义对象不会销毁我们加一个可以少拷贝一次提高效率没有返回的时候因为出作用域就销毁了所以不能加引用会拷贝构造一次 最后再说一下前置和后置 这里参数是空的默认是前置所以返回*this有一个int是后置返回构造的对象 前置--和后置--是一个道理 流插入流提取的实现 全局会重载流插入运算符内置类型会自动识别类型自定义类型的打印需要自己实现 cout的类型是ostream是一个流将内存的值打印到屏幕上从内存流到屏幕上 cin就不写了和cout反着来从屏幕上流入内存 这里不能设成成员函数成员函数默认第一个参数是this不符合cout打印的格式 这里设成友元函数进行操作可以实现正确打印格式 注意 const成员 将 const 修饰的 “ 成员函数 ” 称之为 const 成员函数 const 修饰类成员函数实际修饰该成员函数 隐含的 this 指针 表明在该成员函数中 不能对类的任何成员进行修改 记住const在成员函数后边表示修饰*thisconst在*前边表示修饰指针指向的对象在*后边修饰指针 拿Print成员函数举例子当是const对象时const Date* 不能传给Date* const this 权限放大但是可以传给const成员函数的Print权限缩小并且非const对象也能调用const成员函数的Print是权限缩小 所以我么看到 总结成员函数定义原则 1.能定义成const的成员啊函数都应该定义成const这样 const对象权限平移和非const对象都可以调用 2.要修改成员变量的成员函数不能定义成constconst对象不能调用很合理非const才能调用 请思考下面的几个问题 1. const 对象可以调用非 const 成员函数吗不能权限扩大 2. 非 const 对象可以调用 const 成员函数吗可以权限缩小 记住权限平移或者缩小可以调用权限扩大不行 取地址及const取地址操作符重载 就这两个东西非const对象调用非const版本返回非constconst对象调用const版本返回const一般我们不用实现编译器默认会实现这两个成员函数 如果显示实现会调用显示实现的 没显示实现编译器会自己生成 到此类的6个默认成员函数都讲完了如果有什么问题可以私信或者在评论区交流
感谢支持
下边我把日期类的实现代码结合我们刚才讲的const和operator在复制一份在下边有需要的可以看看(代码都已经测试过没有任何问题细节我能讲的已经全部讲到欢迎友好交流)
日期类完整代码 Date.h
#includeiostream
#includeassert.h
using namespace std;class Date
{
public:Date(int year 1, int month 1, int day 1);void Print() const;int GetMonthDay(int year, int month);bool operator(const Date y) const;bool operator!(const Date y) const;bool operator(const Date y) const;bool operator(const Date y) const;bool operator(const Date y) const;bool operator(const Date y) const;int operator-(const Date d) const;Date operator(int day);Date operator(int day) const;Date operator-(int day);Date operator-(int day) const;Date operator();Date operator(int);Date operator--();Date operator--(int);friend ostream operator(ostream out, const Date d);friend istream operator(istream in, Date d);
private:int _year;int _month;int _day;
};ostream operator(ostream out, const Date d);
istream operator(istream in, Date d); Date.cpp #include Date.hDate::Date(int year, int month, int day)
{_year year;_month month;_day day;if (_year 1 ||_month 1 || _month 12 ||_day 1 || _day GetMonthDay(_year, _month)){//assert(false);Print();cout 日期非法 endl;}
}void Date::Print() const
{cout _year / _month / _day endl;
}bool Date::operator(const Date y) const
{return _year y._year _month y._month _day y._day;
}// d1 ! d2
bool Date::operator!(const Date y) const
{return !(*this y);
}bool Date::operator(const Date y) const
{if (_year y._year){return true;}else if (_year y._year _month y._month){return true;}else if (_year y._year _month y._month _day y._day){return true;}return false;
}bool Date::operator(const Date y) const
{return *this y || *this y;
}bool Date::operator(const Date y) const
{return !(*this y);
}bool Date::operator(const Date y) const
{return !(*this y);
}int Date::GetMonthDay(int year, int month)
{assert(year 1 month 1 month 12);int monthArray[13] { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30,31 };if (month 2 ((year % 4 0 year % 100 ! 0) || (year % 400 0)))return 29;return monthArray[month];
}// d1 100
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;
}Date Date::operator-(int day)
{if (day 0){return *this (-day);}_day - day;while (_day 0){--_month;if (_month 0){--_year;_month 12;}_day GetMonthDay(_year, _month);}return *this;
}Date Date::operator-(int day) const
{Date tmp(*this);tmp - day;return tmp;
}// 21:13继续
// 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
{// 假设左大右小int flag 1;Date max *this;Date min d;// 假设错了左小右大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)
{in d._year d._month d._day;return in;
} test.cpp #include Date.h//void TestDate1()
//{
// Date d1(2023, 10, 1);
// Date d2(2023, 11, 3);
// d1.Print();
//
// cout d1 d2 endl;
//
//
// cin d1 d2;
// cout d1 d2 endl;
//
// int i 0;
// i 10;
//
// /*double d 1.1;
// int i 2;
//
// cout i;
// cout d;*/
//}
//int main()
//{
// TestDate1();
// return 0;
//}int main()
{// const对象和非const对象都可以调用const成员函数const Date d1(2025, 10, 31);//d1.Print();Date d2(2025, 1, 1);//d2.Print();cout d1 endl;cout d2 endl;return 0;
}
