Review cpp day04

已于 2022-06-21 16:10:55 修改
阅读量111 收藏
点赞数
文章标签： c++
于 2021-05-06 16:07:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42284219/article/details/116402889
版权

回顾：
Review cpp day01
Review cpp day02
Review cpp day03

十四、构造函数和初始化表

1、构造函数和普通的函数类似，也可以重载或带有缺省参数

05constuctor.cpp

#include <iostream>
using namespace std;

class Student{
public:
	Student(const string& name, int age = 0, int id = 0){
		cout << "构造函数1" << endl;
		m_name = name;
		m_age = age;
		m_id = id;
	}
	/*
	Student(const string& name){
		cout << "构造函数2" << endl;
		m_name = name;
		m_age = 0;
		m_id = 0;
	}
	*/
	void who(void){
		cout << "我叫" << m_name << "今年" << m_age 
			<< "岁，学号是" << m_id << endl;
	}
private:
	string m_name;
	int m_age;
	int m_id;
};
int main(void){
	//创建对象，构造函数将自动被调用
	Student s("张飞", 28,10011);
	s.who();
	Student s2(关羽");
	s2.who();
	return 0;
}

2、缺省（默认）构造函数

  • 1）如果类中没有定义任何的构造函数，编译器会为该类提供一个缺省（无参）构造函数
    • 对于基本类型的成员变量不做初始化
    • 对于类类型的成员变量，会自动调用相应类的无参构造函数来初始化。
      eg:
	class A{
	public:
		int m_i;//基本类型
		string m_str;//类类型的成员变量（成员子对象）
	};
	A a;//会自动调用无参构造函数创建a对象
	cout << a.m_i << endl;//未知结果
	cout << a.m_str << endl;//一定是空字符串

06defCons.cpp

#include <iostream>
using namespace std;

class A{
public:
	A(void){
		m_i = 1234;
	}
	int m_i;
};
class B{
public:	
	//编译器会给B类提供类似下面的缺省构造函数
	//B(void){}
	int m_j;//基本类型
	A m_a;//类类型（成员子对象）
};
int main(void){
	B b;
	cout << b.m_j << endl;//未知
	cout << b.m_a.m_i << endl;//1234
	return 0;
}
  • 2）如果类中自己定义了构造函数，无论是否有参数，编译器都不会再提供缺省的无参构造函数。

3、类型转换构造函数（单参构造函数）

class 目标类型{
	[explicit] 目标类型(源类型...){...}
};

注： 使用explicit关键字修改构造函数，可以强制要求这种转换必须显式地完成。

07castCons.cpp

#include <iostream>
using namespace std;

class Integer{
public:
	Integer(void){
		cout << "Integer::Interger(void)" << endl;
		m_data = 0;
	}
	//int-->Integer
	//类型转换构造函数
	explicit Integer(int data){
		cout << "Integer::Interger(int)" << endl;
		m_data = data;
	}
	void print(void){
		cout << m_data << endl;
	}
private:
	int m_data;
};
int main(void){
	Integer i;
	i.print();//0

	//发生隐式转换
	//1）Integer tmp(123)
	//2）i = tmp;
	i = 123;//加上explicit关键字后这里会出错
	i.print();//123

	//隐式转换可读性差，推荐显式转换
	//i = (Integer)321;//C风格
	i = Integer(321);//C++风格
	i.print();//321
	return 0;
}

4、拷贝（复制）构造函数

  • 1）用一个已存在的对象构造同类型的副本对象，会调用该类的拷贝构造函数：
	class 类名{
		类名(const 类名& ...){...}
	};

eg:

	class A{...};
	A a1;
	A a2(a1);

08cpCons.cpp

#include <iostream>
using namespace std;

class A{
public:
	A(int data = 0){
		cout << "A::A(int)" << endl;
		m_data = data;
	} 
	A(const A& that){
		cout << "A::A(const A&)" << endl;
		m_data = that.m_data;
	}
	int m_data;
};
int main(void){
	A a1(123);
	//A a2 = a1
	A a2(a1);//调用A类的拷贝构造函数
	cout << a1.m_data << endl;//123
	cout << a2.m_data << endl;//123
	return 0;
}
  • 2）如果每一个类没有自己定义拷贝构造函数，那么编译器会为该类提供一个缺省的拷贝构造函数：

    • 对于基本类型的成员变量，按字节复制；

    • 对于类 类型成员变量（成员子对象），会调用相应类的拷贝构造函数初始化。

      注： 一般情况不需要自己定义拷贝构造函数，因为编译器所提供的缺省拷贝构造函数已经很好用了。

09cpCons.cpp

#include <iostream>
using namespace std;

class A{
public :
	A(int data = 0){
		cout << "A::A(int)" << endl;
		m_data = data;
	} 
	A(const A& that){
		cout << "A::A(const A&)" << endl;
		m_data = that.m_data;
	}
	int m_data;
};

class B{
public:
	int m_i;//基本类型的成员变量
	A m_a;//类类型的成员变量（成员子对象）
};
int main(void){
	B b1;
	b1.m_i = 123;
	b1.m_a.m_data = 1234;
	B b2(b1);//调用B的拷贝构造函数
	cout << b1.m_i << ',' << b1.m_a.m_data << endl;//123,1234
	cout << b2.m_i << ',' << b2.m_a.m_data << endl;//123,1234
	return 0;
}

  • 3）拷贝构造函数调用时机

    • 用已存在的对象作为同类型对象的构造实参
      A a1;
      A a2(a1);
      //A a2 = a1;//和上面等价
    • 以对象形式向函数传递参数
      void foo(A a){}
      foo(a1);
    • 从函数中返回对象(有可能被编译器优化掉)
      A foo(void){
      A a;
      return a;
      }
    • 用类类型接受函数返回值
      A foo(void){
      A a;
      return a;
      }
      A a = foo();

  • 下面的代码调用了6次构造函数（包括无参和拷贝的构造函数）
    10cpCons.cpp

#include <iostream>
using namespace std; 

class A{
public:
	A(void){
		cout << "A::A(void)" << endl;
	}
	A(const A& that){
		cout << "A::A(const A&)" << endl;
	}
};
void func1(A a){}
A func2(void){
	A a;//无参
	cout << "&a" << &a << endl;
	return a;//拷贝
}
int main(void){
	A a1;//无参
	A a2 = a1;//拷贝
	func1(a1);//拷贝
	/*func2正常返回a拷贝到临时对象，然后再拷贝到a3.发生两次拷贝，但
	* 是因为编译器的优化，让a3直接引用a不再发生拷贝
	*/
	//去优化选项：g++  -fno-elide-constructors 10cpCons.cpp
	A a3 = func2();//拷贝
	cout << "&a3" << &a3 << endl;
	return 0;
}

5、初始化表

  • 1）语法
    class 类名{
    类名(形参表):成员变量(初值){//构造函数体}
    };

eg:

	class A{
	public:
		A(int i):m_i(i), m_i2(0){
			//m_i = i;
		}
		int m_i;
		int m_i2;
	};

01initlist.cpp

#include <iostream>
using namespace std;

class Student{
public:
	//先把成员变量定义出来，再赋初值	
	/*Student(const string& name, int age, int no){
		m_name = name;
		m_age = age;
		m_no = no
	}*/
	//定义成员变量时，同时初始化
	Student(const string& name, int age, int no)
		:m_name(name), m_age(age), m_no(no){}
	void who(void){
		cout << m_name << ',' << m_age << ',' << m_no << endl;
	}
private:
	string m_name;
	int m_age;
	int m_no;
};
int main(void){
	Student s("张飞", 28, 10011);
	s.who();
	return 0;
}
  • 2）多数情况下使用初始化表和在构造函数体中进行赋初值没有太大差异，可以任选一种方式，但是在某些特殊情况下必须要使用初始化表：
    • (1)如果有类 类型的成员变量，而该类又没有无参构造函数，则必须通过初始化表来初始化该变量。
      02initlist.cpp
#include <iostream>
using namespace std;

class A{
public:
	A(int data){
		cout << "A的构造函数"<< endl;
		m_data=data;
	}
	int m_data;
};

class B{
public:
	B(void):m_a(1234){
		cout << "B的构造函数" << endl;
	}
	A m_a;//类 类型成员变量
};
int main(void){
	B b;
	cout << b.m_a.m_data << endl;//1234
	return 0;
}

A的构造函数
B的构造函数
1234
  • (2)如果类中包含“const”或“引用”型的成员变量，必须要使用初始化表来初始化。
    const int num;
    num = 0;//这两个语句本身就是错误的，必须定义时同时初始化

03initlist.cpp

#include <iostream>
using namespace std;

int num = 100;

class A{
public:
	/*A(void){
		m_r = num;
		m_c = 200;
	}*/error
	A(void):m_r(num), m_c(200){}
	int& m_r;
	const int m_c;
};

int main(void){
	A a;
	cout << a.m_r << ',' << a.m_c << endl;
	return 0;
}

注： 成员变量的初始化的顺序由声明顺序决定，而与初始化表的顺序无关，不要用一个成员变量去初始化另一个成员变量。

04initlist.cpp

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

class Dummy{
public:
	/*Dummy(const char* psz)
		:m_str(psz), m_len(m_str.size()){}*/
	Dummy(const char* psz)
		//:m_str(psz), m_len(strlen(psz)){}
		:m_str(psz ? psz:""), m_len(strlen(psz ？psz:"")){}
	//类的成员变量的初始化不是按初始化表的顺序，而是成员变量的声明顺序
	/*
	string m_str;
	size_t m_len;
	*/

	string m_str;
	size_t m_len;
};
int main(void){
	//Dummy d("hello world!");
	Dummy d(NULL);
	cout << d.m_str << "size=" << d.m_len << endl;
	return 0;
}

  • 练习：修改电子时钟类，增加计时器功能，要求使用初始化表

    • 1）如果以系统时间构造对象，表示时钟功能
    • 2）如果以无参构造对象，使用初始化表将时间初始化为0，表现为计时功能。
      05Clock.cpp

  • 扩展练习2.0：实现企业员工系统

    • 需求：修改和完善一个员工类
      • 1）为Employee增加构造函数（有参、无参）
      • 2）将类分成多文件实现：
        Employee.h//声明
        Employee.cpp//实现
      • *3）编写Makefile

Employee.h:

class Employee{
public:
	string m_name;
	int m_id;
private:
	double m_sarary;

public:
	Employee();
	Employee(int, string);
	void print(void);
	void countSarary(void);
};

Employee.cpp:

#include "Employee.h"
Employee::Employee(){
	cout << "Employee::Employee()" << endl;
}
Employee::Employee(int id, string m_name){
	cout << "Employee::Employee(int, string)" << endl;
	m_id = id;
	m_name = name;
}
void Employee::print(void){
	cout << m_id << "," << m_name << endl;
}
void Employee::countSarary(void){
	int days = 0;
	double fun_sarary = 0;
	double ex_sarary = 0;
	cout << "请输入出勤天数：";
	cin >> days;
		
	fun_sarary = 4000 * (days / 23.0);
	ex_sarary = fun_sarary / 2;
		
	m_sarary = fun_sarary + ex_sarary;
	cout << "总工资是：" << m_sarary << endl;
}

main.cpp:

int main(void){
	Employee e;
	return 0;
}

Makefile

a.out:Employee.o main.o
	g++  *.o
Employee.o:Employee.cpp
	g++ -c Employee.cpp
main.o:main.cpp
	g++ -c main.cpp
clean:
	rm *.o a.out
Ascenda
关注
C++课后习题第三章
weixin_44906474的博客
10-12 4813
课本习题第三章第二题第三题第四题第五题 第三章 第二题 题目： 分析下列程序，写出其运行结果。 代码： #include<iostream> using namespace std; class Data { public: Data(int,int,int); Data(int,int); Data(int); Data(); void display(); private: int month; int day; int year; }; Data::Data(int
谭浩强C++ 第九章
mlamao的博客
11-24 1592
第九章课后习题 1、 2、 3、 4、 5、
【c++类和对象——设计一个学生类】
qq_64895642的博客
05-07 2615
设计一个学生类，属性有姓名和学号，可以给姓名和学号赋值，并且可以显示。 #include<iostream> using namespace std; #include<string> class student { public: int m_Id;//成员变量（属性） string m_name;//成员变量（属性） void showstudent()//成员函数（行为） { cout<<"姓名："<<m_name<&
QT学习之C++面向对象基础
NameisBoy的博客
08-11 735
QT学习之C++面向对象基础 1. 类和对象 1.1 类的定义 C++中的类可以简单看作是结构体的升级版，但是在类中成员不仅可以是变量也可以是函数。变量可以称作类的属性，函数可以称为类的方法。 示例： class stduent { public: int id;//成员之1 int age;//成员之2 void test(void);//成员之3，函数 private: int score;//成员之4 }; 创建的方法类似结构体的定义方法，关键字 publi
C++资料（三）——如何使用类和对象
FFFPAG的博客
08-07 686
类和对象的使用说明构造函数对类的对象进行初始化析构函数进行清理工作对象数组对象指针公用数据的保护对象的动态建立和释放对象的赋值和复制静态成员友元类模板 构造函数对类的对象进行初始化 析构函数进行清理工作 对象数组 对象指针 公用数据的保护 对象的动态建立和释放 对象的赋值和复制 静态成员 友元 类模板 ...
我的.emacs(Ubuntu版)(二十二)
Android系统攻城狮
02-16 1037
;;Load site-lisp (add-to-list 'load-path "~/.emacs.d/site-lisp") ;;显示行号 (add-to-list 'load-path "/usr/share/emacs/site-lisp") (require 'linum) (global-linum-mode t) (setq column-number-mode t);显示列号 ...
8-07-14_MegaCLI for linux_windows
03-15
包含如下操作系统版本 FreeBSD Linux Solaris Windows 分别对应如下目录 MegaCLI for DOS MegaCLI for Linux MegaCLI for Solaris MegaCLI for FreeBSD MegaCLI for Windows ********************************...
PMP中英文术语对照
不怂，不弱，不退缩，厚积薄发
07-19 1万+
ABC|参见Activity Based Costing ABM|参见Activity Based Management Abstract Resource|抽象资源 Abstraction|抽象 AC|实际费用 Acceleration|加速 Acceptability Criteria|验收标准 Acceptable|可接受的 Acceptable Quality Level|(AQL) 可接受质量水平 Acceptance|验收 Acceptance Criteria|验收标准 Acceptance
板凳——————————————————c++(104)
fengye207161的博客
03-13 1559
c++ Primer Plus (第六版) #if 0 #include int main(){ unsigned int yards {}, feet{}, inches {}; std::cout << "Enter a distance as yards, feet, and inches " << “with the three values separated by spaces:” << std::endl; std::cin >> yards
安徽科技学院 2014-2015-2学期计算机14级12班《C语言程序设计II》期末考试
热门推荐
jtahstu的专栏
07-06 3万+
安徽科技学院 2014-2015-2学期计算机14级12班《C语言程序设计II》期末考试
C++面向对象程序设计第三章部分课后习题
Atticus的博客
10-23 3248
三、 我修改的程序如下： #include<iostream> using namespace std; class Date { public: Date(int = 1, int = 1, int = 2005); void display(); private: int month; int day; int year; }; Date::Date(int m, int d, int y):month(m), day(d), year(y) { } void
C++实验： 类和对象（二）
阡陌笙的博客
08-26 1536
C++实验： 类和对象（二） 1.实验目的 （1）进一步加深对类和对象的理解。 （2）掌握类的构造函数和析构函数的概念和使用方法。 （3）掌握对象数组、对象的指针及其使用方法。 （4）掌握友元的概念与使用。 （5）了解类模板的使用方法。 2.实验内容 （1）修改已知程序，增加一个fun函数，在main函数中调用，同时在fun函数中调用display与change函数，使用对象的引用（Student&）做形参； （2）编写程序，使用静态数据成员与静态成员函数，计算出此商品的总销售款sum与每件商品的平
C++派生类构造函数实战
实践求真知
05-02 475
一代码 #include<iostream> #include<string> using namespace std; class CStudent{//声明基类Student public: CStudent(int n,string nam,char s){//基类构造函数 num=n; name=nam; sex=s;...
关于C++的类详细解析（学习笔记）
Cser_zhu的博客
07-17 1462
类的定义 class 类型名 { 数据成员 成员函数 }; 这里类型名相当于一种数据类型，用来定义对象。 公共、私有和保护 private 只有该类的成员函数和友元函数才能访问这些成员 public 所有的函数都可以访问这些函数 protected 在具有private特性的同时，可以由派生类（通过继承而生成的类中的成员函数来访问 数据成员和成员函数 成员函数的使用 首先定义一个类的对象，格式为： 类名 对象名 有了对象之后，就可以用对象来访问类中的成员函数了。可以用句点或者指针形式，定义一个
用参数初始化表对学生信息初始化并输出学生信息
AKK188888881的博客
05-18 986
用参数初始化表对学生信息初始化并输出学生信息 #include<iostream> #include<cstring> using namespace std; class Student { /*如果数据成员是数组，则应当在构造函数的函数体中用语句对其赋值，而不能在参数初始化表中对其初始化*/ public: Student(int n,char s,const char nam[]):num(n),sex(s)//定义构造函数 { strcpy(name,
c++类的组合
qq_66954747的博客
06-05 1369
初始化参数列表 类的组合 this指针 类中类
R5-1将空白的地方填写完整，使程序完成指定的功能。
77生活工作室的博客
07-11 2240
#include <iostream> using namespace std; class Student {public: Student(int n,float s):num(n),score(s){} //利用参数初始化表进行数据初始化 void display(); private: int num; float score; }; void Student::display() {cout<<num<<" "<&l.
c++填空题
bless_my_head的博客
07-10 7394
5-1 阅读下面的程序，完成其中复制构造函数的代码。 #include <iostream> using namespace std; class CAT { public: CAT(); CAT(const CAT&); ~CAT(); int GetAge() const { return *itsAge; } void SetAge(int age){ *itsAg
C++(一)
最新发布
qq_52684761的博客
02-18 194
基于C语言的c++的学习，初步学习c++。
ReviewBoard安装与配置全攻略
"ReviewBoard安装配置手册，涵盖了从安装到配置的详细步骤，适用于ReviewBoard 1.5RC1版本。这份指南由yunshandi编写，包括了安装前的准备、ReviewBoard安装、站点创建、Apache配置、ReviewBoard配置、样式配置、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值