14v.cpp

《C/C＋＋程序设计导论（第二版）》一书的程序源文件

// Adv_Set.cpp  Implementation file for Adv_Set class
#include <iostream.h>
#include "Adv_Set.h"

Set::Set () 					// default constructor
{	size = 0;
	members = NULL;
}

Set::Set (const Set& s)				// deep-copy constructor
{	int n;
  	members = new int[s.size];		// alloc. new array of correct size
	size = s.size;
   for (n=0; n<size; n++)           // copy set members over
      members[n] = s.members[n];
}

Set& Set::operator= (const Set& s)		// deep-copy assignment
{	int n;
   if (members == s.members)     //when a set is assigned to itself (A=A)
      return(*this);
	delete [] members;			// dealloc. prev. array (if any)
	members = new int[s.size];		// alloc. new array of correct size
	size = s.size;
	for (n=0; n<size; n++)			// copy set members over
		members[n] = s.members[n];
	return (*this);
}

Set::~Set ()					// destructor
{	delete [ ] members;
}

// Union returns a new set containing members of both sets
Set Set::operator+ (Set s)					// union of sets
{	int j, pos;
	Set temp;
// first determine the new set size; the size of the owner set plus the
//   number of members of the arg. set which are not  in the owner set.
	temp.size = size;
	for (j=0; j<s.size; j++)
		if (!IsMember(s.members[j]))
			temp.size++;
	temp.members = new int[temp.size];					// allocate new array
// Now copy over the owner set, then the members of the arg. set which
//   are not already in the owner set.
	for (j=0; j<size; j++)
		temp.members[j] = members[j];
	pos = size;
	for (j=0; j<s.size; j++)
		if (!IsMember(s.members[j]))
			temp.members[pos++] = s.members[j];
	return (temp);
}

// Subtraction returns a new set containing only members of owner set
//   that do not also appear in the arg. set.
Set Set::operator- (Set s)						// subtraction of sets
{	int j, pos;
	Set temp;
// first determine the new set size; the size of the owner set minus the
//   number of members of the arg. set which are also in the owner set.
	temp.size = size;
	for (j=0; j<s.size; j++)
		if (IsMember(s.members[j]))
			temp.size--;
	temp.members = new int[temp.size];					// allocate new array
// Now copy over the owner set, skipping the members of the arg. set which
//   are also in the owner set.
	for (j=pos=0; j<size; j++)
		if (!s.IsMember(members[j]))
			temp.members[pos++] = members[j];
	return (temp);
}

// Intersection returns a new set containing only members that appear in
//   both the owner set and the arg. set.
Set Set::operator & (Set s)                       // intersection of sets
{  int j, pos;
	Set temp;
// first determine the new set size; the size of the owner set minus the
//   number of members in the owner set that are not in the arg. set.
	temp.size = size;
	for (j=0; j<size; j++)
		if (!s.IsMember(members[j]))
			temp.size--;
	temp.members = new int[temp.size];             // allocate new array
// Now copy over the owner set, skipping the members not appearing in
//   both sets.
	for (j=0, pos=0; j<size; j++)
		if (s.IsMember(members[j]))
			temp.members[pos++] = members[j];
	return (temp);
}

int Set::IsMember (int n)
 { int k;
	for (k=0; k<size; k++)
		if (n == members[k])
			return (1);
	return (0);
 }

// Subtraction of a specific integer from a set
Set Set::operator- (int n)
{  int k, j=0;
	Set temp;
	if (!IsMember(n))
		return (*this);
	else
	{  temp.members = new int[size-1];
		for (k=0; k<size; k++)
			if (members[k] != n)
				temp.members[j++] = members[k];
		temp.size = j;
		return (temp);
	}
}

// Union of an integer into a set
Set Set::operator+ (int n)
{  int k;
	Set temp;
	if (IsMember(n))
		return (*this);
	else
	{  temp.members = new int[size+1];
		for (k=0; k<size; k++)
			temp.members[k] = members[k];
		temp.members[size] = n;
		temp.size = size+1;
		return (temp);
	}
}

void Set::Output(ostream& outs)
{
	int n;

	for (n=0; n<size; n++)
		outs << members[n] << ',';
	outs << '\n';
}

void Set::Reset(void)
{
	if (size)
		delete[] members;
	size = 0;
	members = NULL;
}