学完C再学C++(5) 类和动态内存分配

/*
第12章 类和动态内存分配
1.动态内存和类
	若类的成员用static 那无论创建了多少个对象，都只分配一个static，都共享这个static的变量，非常方便。
	不要在类声明中初始化static的变量，例外是const static。

	stringbad例子
		有点长，概括起来就是某个函数按值传参，效果就是在函数里创建了一个新的stringbad对象，传完参数再析构函数释放，这一过程自动完成。
	结果stringbad 里面成员用的指针，指向的字符，若要释放字符所在的空间，析构函数里面就要写delete删字符数组，所以调用1次那个传值函数就会调用一次析构函数，能把你字符数组全删了。	
		而且计数会少计因为用一个对象给另一个对象初始化，会自动生成一个参数为stringbad的构造函数。而不是用那个参数是常量的构造函数。
	bad的原因：隐式的赋值构造函数和隐式的析构函数。

	一、默认构造函数
		没有构造函数C++会创建一个啥都不干的构造函数。自己创建默认构造函数不能带参数或者有默认参数。
		ClassName(){xx=0;}   ClassName(int xx=0){}两个不能同时有，因为有二义性。

	二、复制构造函数
		创建对象时将另一个对象赋值给这个对象。ClassName (const ClassName & c);
		下列情况会调用这种。
		ClassName c1(c2);
		ClassName c1=c2;.......
	
	某个函数按值传递对象时，返回值赋值给左边的，就会使用复制构造函数，创建对象没有参数时使用默认构造函数。
	三、赋值运算符号
		等号赋值不会复制字符串数组，因为他不属于对象里的，只复制了一个指针，两个对象共用一块空间很明显不常在，要出错。
		所以要重载等号
	这一节最重要的是知道啥时候会调用构造和析构函数。
2.构造函数使用new注意事情
	一、有new有delete
	二、new [] dedlete[] 
	三 多个构造函数相同的new方式.
最后一节是实现消息队列,没看了,直接做题.
*/

#include <iostream>
#include <fstream>
#include<string.h>
#include "study.h"//里面写的#define DAY1....


#ifdef DAY6
//课后题3，栈,
#ifndef Hfile
//头文件部分

typedef unsigned long unlong;

using namespace std;
class stack
{
private:
	enum{ MAX = 10 };
	unlong* item;
	int size;
	int top;
public:
	stack(int n = MAX);
	//防止构造时生成默认的,默认的会直接复制对象,里面指针还是没变
	stack(const stack& st);
	~stack();
	bool isempty()const;
	bool isfull()const;
	bool push(const unlong & data);
	bool pop(unlong& data);
	void show();
	//防止直接相等
	stack & operator=(const stack& st);	
};
#endif

stack::stack(int n)
{
	if (n > 10)n = 10;
	size = 0;
	item = new unlong[n];
	top = n;
	std::cout << "created a stack Maxsize" << top << endl;
}
stack::stack(const stack& st)
{
	top = st.top;
	size = st.size;
	item = new unlong[top];
	memcpy(item, st.item, sizeof(unlong) * st.top);
}
stack::~stack()
{
	delete [] item;
}
//1是空的,0是非空
bool stack::isempty()const
{
	//for (int i = 0; i < top; i++)
	//{
	//	if (item[i] != 0)return 0;
	//}
	if (size == 0)return 1;
	return 0;
}
//1是满的,0不满
bool stack::isfull()const
{
	//for (int i = 0; i < top; i++)
	//{
	//	if (item[i] == 0)return 0;
	//}
	if (size == top)return 1;
	else return 0;
}
//1是成功,0是满的的推不入
bool stack::push(const unlong& data)
{
	if (isfull())
	{
		std::cout << "full and can not to push" << endl;
		return 0;
	}
	item[size]=data;
	size++;
	std::cout << "push ;" << data << endl;
}
//1是成功,0是空的,推不出
bool stack::pop(unlong& data)
{
	if (isempty())
	{
		std::cout << "empty and can not to pop" << endl;
		return 0;
	}
	data=item[size-1];
	item[size - 1] = 0;
	size--;
	std::cout<<"pop ;"<< data<<endl;
	return 1;
}
//为了防止赋值时把指针也复制过去
stack& stack::operator=(const stack& st)
{
	top = st.top;
	size = st.size;
	item = new unlong[top];
	memcpy(item, st.item, sizeof(unlong) * st.top);
	return *this;
}
void stack::show()
{
	std::cout << "show:" << endl;
	for (int i=0; i < size; i++)
	{
		std::cout << item[i] << ", ";
	}
	std::cout << endl;
}
int main()
{
	int n = 11;
	unlong a = 8;
	stack s1;
	stack s2;

	while (n--)
	{
		s1.push(n);
	}
	n = 11;
	s1.show();
	
	s2 = s1;
	stack s3 = s1;
	//stringbad的坑,如果是直接相等s2,s3也会被清空
	while (n--)
	{
		if (s1.pop(a));
	}
	s1.show();
	s2.show();
	s3.show();
	return 0;
}

#endif`