Removing Elements From an Array with Overloaded Operators

[BreezedStars]

I asked this question last night and I didn't get any replies. I figure I'd give it another go.

I'm writing a program that works with two sets of numbers put into arrays. The program uses overloaded + and - operators.
Array one: {2 7 4 2 9 7}
Array two: {2 9 8 9 1 10 12}
The output should be:
For +, New Array: {2 7 4 9 10 8 1 12}
For -, New Array: {7 4 2 7}
My output is: Addition: 12 10 1
Subtraction: 12 9 8 9 1 10


I'm getting the wrong output and I don't see what I am doing wrong.
How can I fix it?

Any help is Appreciated. Thanks!

   bool set::erase_one(const value_type& target)
    {
         size_type index = 0;  
	 while ((index < used) && (data[index] != target))
         {
              ++index;
         }
	 if (index == used)
	 {
              return false;
         }
             
         --used; 
	 data[index] = data[used];    
	 return true;
    }

    bool set::contains(const value_type& target) const
    {
         size_type i;
         for(i = 0; i < used; i++)
         {
               if(target == data[i])
               {
                     return true;
               }
         }
         return false;
    }    

    void set::insert(const value_type& entry)
    // Library facilities used: cassert
    {   
        assert(size( ) < CAPACITY);

        data[used] = entry;
	    ++used;
    }
    
    set operator +(const set& b1, const set& b2)
    {
        size_t index;
        set answer(b1), two(b2);
        for(index = 0; index < answer.size(); index++) 
        {
              int target = answer.data[index]; 
              if(answer.contains(target))
              {
                    answer.erase_one(target);
              }
        }
        
        for(index = 0; index < two.size(); index++) 
        {
              int target = two.data[index];
              if(two.contains(target))
              {
                    two.erase_one(target);
              }
        }   
             
        for(index = 0; index < answer.size(); index++) /
        {
              int target = two.data[index];
              if(target != two.data[index])
              {
                    answer.insert(target);
              }
        }
        return answer;
    }
    
    set operator-(const set& b1, const set& b2)
    {
        size_t index;
	    set answer(b1), two(b2); 
	    for (index = 0; index < two.size(); ++index) 			
	    {
		    int target = two.data[index]; 
		    if (answer.contains(target)) 
		    {
			   answer.erase_one(target);
            }
	}
	return answer;
    }

From my header:

typedef size_t size_type;
size_type size( ) const { return used; }
int used; //Size of each array
int data[CONSTANT]; //CONSTANT = 30 

[kbw]

insert() should deal with duplicates and ordering.

Why does operator+ call erase_one? And why does it make a copy of b2? You should be able to just insert values and let the set deal with duplicates.