c++学习点滴6

一、构造函数

class NoName {
public:
	NoName();
	explicit NoName(const char *);
	NoName(const char *, int);
	NoName(const char *, int, double);
	NoName(const NoName&);

	virtual ~NoName();

protected:
	char *pstr;
	int ival;
	double dval;
private :
	void initNoName(const char *ps);
};

void NoName::initNoName(const char *ps) {
	if (ps) {
		pstr = new char[strlen(ps)+1];
		strcpy(pstr, ps);
	} else {
		pstr = new char[1];
		*pstr = '\0';
	}
}

NoName::NoName() {
	pstr = new char[1];
	*pstr = '\0';
	ival = 0;
	dval = 0;
}

NoName::NoName(const char *ps) {
	initNoName(ps);
	ival = 0;
	dval = 0;
}
NoName::NoName(const char *ps, int i) {
	initNoName(ps);
	ival = i;
	dval = 0;
}
NoName::NoName(const char *ps, int i, double d) {
	initNoName(ps);
	ival = i;
	dval = d;
}
NoName::NoName(const NoName &rhs) {
	initNoName(rhs.pstr);
	ival = rhs.ival;
	dval = rhs.dval;
}
NoName::~NoName() {
	delete pstr;
	pstr = 0;
	
}

使用带缺省值的构造函数：

class NoName {
public:
	NoName(const char *ps=0, int i =0, double d=0);
	NoName(const NoName&);

	virtual ~NoName();

protected:
	char *pstr;
	int ival;
	double dval;
private :
	void initNoName(const char *ps);
};

void NoName::initNoName(const char *ps) {
	if (ps) {
		pstr = new char[strlen(ps)+1];
		strcpy(pstr, ps);
	} else {
		pstr = new char[1];
		*pstr = '\0';
	}
}
NoName::NoName(const char *ps, int i, double d) {
	initNoName(ps);
	ival = i;
	dval = d;
}
NoName::NoName(const NoName &rhs) {
	initNoName(rhs.pstr);
	ival = rhs.ival;
	dval = rhs.dval;
}
NoName::~NoName() {
	if (pstr) {
		delete pstr;
		pstr = 0;
	}
}

二、初始化

// C++的数据成员中，只允许const static的数据成员在定义时被初始化
/*
class Test {
private:
	//int i = 0; // error
	//const int i = 0; // error
	//static int i = 0; // error
	const static int i = 0; // ok
};
*/

/*
class MyMember1  {
public :
	MyMember1(){}  // 有默认构造函数
};

class MyMember2 {
public :
	MyMember2(int i){}; // 没有默认构造器
};


// c++ 类的初始化分为隐式初始化、显示初始化、和计算部分(构造函数体内的所有语句)
// 隐式初始化包括: 1.调用所有父类的默认构造器  2.调用所有类成员的默认构造器
// 显示初始化，通过成员列表进行的初始化(推荐这样做)
// 计算部分，即位于构造器内部的所有语句
// 初始化顺序按照成员声明的顺序，而非初始化列表中的顺序。所以为了方便理解，我们要以成员声明的顺序去进行初始化
class MyClass {
public:
	MyClass(){} // 没有成员列表初始化
private :
	MyMember1 m1; // ok。能通过
	MyMember2 m2; // error。对于没有默认构造器的类成员，只能通过成员列表进行初始化
};
*/

/*
class MyMember1 {
public:
	MyMember1(int i){}
};
// 只能通过列表初始化的方式去初始化的情况：
// 1. const(非static)的成员
// 2. 引用成员
// 3. 没有默认构造函数的那些类成员
class MyClass {
public:
	MyClass() :i(100), ri(i), ci(200), m1(3){}
private:
	int i;
	int &ri;
	const int ci;
	MyMember1 m1;
};
*/