c++学习点滴6

最新推荐文章于 2025-01-09 00:09:25 发布

原创最新推荐文章于 2025-01-09 00:09:25 发布 · 520 阅读

0 ·

CC 4.0 BY-SA版权

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;
};
*/

三、extern关键字使用：

1. 在xx.cpp中定义函数和变量
int i10 = 10;

void fun(const char* str) {
	std::cout << "fun(): " << str << std::endl;
}

2. 在xx.h中用extern声明这些变量和函数
extern int i10;
extern void fun(const char* str);

3. 在别的yy.cpp中包含该xx.h头文件
#include "xx.h"
然后在yy.cpp中直接使用这些变量和函数
int main() {
	fun("allei");
	cout << "i10=" << i10 << endl;
	return 0;
}

四、static关键字

1. static全局变量
  * 只能在本文件访问，对于其他文件不可见。其他文件中可以定义同名的变量而不会冲突。
   * 保存在全局数据区，默认初始化为0
   * 普通全局变量，可以通过extern在其他文件中引用

2. static 局部变量
   * 不会随着函数调用结束而释放，而是继续保留上次被调用的值。在全局数据区分配空间，在第一次调用时被初始化，后续调用不再进行初始化

3. static函数
  * 和普通函数的区别是只在本文件中可见，不能通过extern的方式被其他文件引用

4. class中的静态成员
  * 属于类而非类的对象