好委屈，调试通过后，哭了

昨晚上看到 百度 知道上有个提问，想帮他忙，写完程序后，运行总是有问题。把各种编译错误改正后，还是有问题。

因为是逻辑上的失误，很不容易检查出来，只是提示内存不允许读取，感觉好难过。

好不容易调试通过了，感觉自己好委屈。

以后遇到这种事情要坚强，大不了从头再来，一步步调试。

逻辑错误最可怕，要勇于从头一行一行的调试，不要气馁！

main.cc 源程序

#include <iostream>
#include <string>
#include <sstream>
#include <cctype>
#include <vector>
#include <cmath>
#include <bitset>
#include <algorithm>
#include <cstddef>
#include <iomanip>
#include <stdexcept>
#include <cassert>
#include "set.h"
int main(int argc,char * argv[])
{
int cnt_of_set(1);
std::cout<<"请选择要创建的集合类型，1为int型集合，2为string型集合："<<std::endl;
int choice(0);
std::cin>>choice;
std::string obj_name;
std::cout<<"请输入要创建的集合名字（字母、数字、下划线组成,空格隔开每个名字）："<<std::endl;
while(obj_name=="")
{
std::cin.clear();
std::getline(std::cin, obj_name);
}
for(int i=0;i<obj_name.size()-1;++i)
{
if((::isalnum(obj_name[i])||obj_name[i]=='_')&&(::isspace(obj_name[i+1])))
++cnt_of_set;
}
std::string * sets_name_ptr=new std::string[cnt_of_set]();
try
{
int i(0);
std::string temp;
std::stringstream ss;
ss<<obj_name;
while(ss>>temp)
{
sets_name_ptr[i++]=temp;
}
}
catch(std::runtime_error e)
{
std::cout<<e.what()<<std::endl;
}
std::vector<set<std::string>> set_vec(cnt_of_set);


std::cout<<"请依次输入每个集合中的元素，用空格隔开每个元素，每行输入一个集合，(回车结束一行的输入)："<<std::endl;
for(int ii=0;ii<cnt_of_set;++ii)
{
   std::cout<<"现在请输入集合"<<sets_name_ptr[ii]<<"中的元素，回车结束本集合的输入："<<std::endl;
std::string input;
while(input=="")
{
std::cin.clear();
std::getline(std::cin,input);
}
bool flag_right_input(true);
do
{
int i(0);
for(std::string::size_type i(0);i<input.size();++i)
{
if( ( (::isalnum(input[i]) )|| (::isspace(input[i])) || (input[i]=='_') )==false )
{
flag_right_input=false;
i=1;
break;
}

}
if(i==0)
flag_right_input=true;
if(flag_right_input==false)
{
std::cin.clear();
std::getline(std::cin,input);
}

}
while(!flag_right_input);
size_t arr_size(1);
for(std::string::size_type i(0);i<input.size()-1;++i)
{
if(( ::isalnum(input[i])||input[i]=='_')&&::isspace(input[i+1]))
++arr_size;
}
std::string *  ptr=new  std::string[arr_size]();//已处理
std::stringstream ss;
std::string obj_of_type;
ss<<input;
size_t temp_add(0);
while(ss>>obj_of_type)
{
ptr[temp_add++]=obj_of_type;

}
set<std::string> obj_set(ptr,arr_size);
set_vec[ii]=obj_set;
delete []ptr;
if(ii==cnt_of_set-1)
std::cout<<"所有集合输入成功！"<<std::endl;
}
while(std::cin)
{
std::cout<<"集合并集操作符\t+\t集合交集操作符\t&\n集合补集操作符\t-"<<std::endl;
std::cout<<"\n输入操作表达式的时候，请将操作符跟集合名用空格分开。"<<std::endl;
std::cout<<"请输入操作表达式："<<std::endl;
std::string input;
std::getline(std::cin,input);
int arr_size(1);
for(size_t i=0;i<input.size()-1;++i)
{
if( ((::isalnum(input[i]))||input[i]=='+'||input[i]=='-'||input[i]=='&')&&(::isspace(input[i+1])) )
++arr_size;
}
std::string * operand_name_ptr=new std::string[arr_size]();//已处理
try
{
int i(0);
std::string temp;
std::stringstream ss;
ss<<input;
while(ss>>temp)
{
operand_name_ptr[i++]=temp;
}
}
catch(std::runtime_error e)
{
std::cout<<e.what()<<std::endl;
}
int * ptr_ptr=new int[arr_size]();//已处理
std::vector<int> ivec;
for(int i=0;i<arr_size;i+=2)
{
for(int j=0;j<cnt_of_set;++j)
{
if(sets_name_ptr[j]==operand_name_ptr[i])
{
ptr_ptr[i]=1;
ivec.push_back(j);
}
}
}
bool flag_ok_operand(true);
for(int i=0;i<arr_size;i+=2)
{
if(ptr_ptr[i]==0)
{
std::cout<<"发现错误：集合 "<<operand_name_ptr[i]<<" 不存在！"<<std::endl;
   flag_ok_operand=false;
}
}
bool flag_ok_operator(true);
for(int i=1;i<arr_size;i+=2)
{
if(!((operand_name_ptr[i]=="+")||(operand_name_ptr[i]=="-")||(operand_name_ptr[i]=="&")))
{
flag_ok_operator=false;
std::cout<<"发现错误：操作符 "<<operand_name_ptr[i]<<"非法！"<<std::endl;
}
}
if(flag_ok_operand&&flag_ok_operator)
{

set<std::string> transaction_set;
int _temp(1);
set<std::string> left_operand=set_vec[ivec[0]];
for(int i=1;i<arr_size;i+=2)
{

if(operand_name_ptr[i]=="+")
left_operand =left_operand+set_vec[ivec[_temp]];
if(operand_name_ptr[i]=="-")
left_operand =left_operand-set_vec[ivec[_temp]];
if(operand_name_ptr[i]=="&")
left_operand =left_operand&set_vec[ivec[_temp]];


 ++_temp;


}
std::cout<<"表达式产生的新集合元素为：{ "<<left_operand<<"  }"<<std::endl;
delete [] operand_name_ptr;
delete [] ptr_ptr;




}


//std::cin.clear();
}

delete [] sets_name_ptr;
return 0;
}

set.h 头文件

#include <iostream>
#include <string>
#include <sstream>
#include <cctype>
#include <vector>
#include <cstddef>


template<class type_name> class set
{
template <typename type_name> friend set<type_name> operator+(set<type_name>&,set<type_name>&);
template <typename type_name> friend set<type_name> operator&(set<type_name>&,set<type_name>&);
template <typename type_name> friend set<type_name> operator-(set<type_name>&,set<type_name>&);
template <typename type_name> friend std::ostream & operator<<(std::ostream &,set<type_name>&);
public:
set();
set(std::vector<type_name> &);
set(const type_name * iptr,const int size);
//virtual ~set();
private:
std::vector<type_name> ivec;


};
template <typename type_name> set<type_name>::set(){}//ivec=std::vector<type_name>();}
template <typename type_name> set<type_name>::set(std::vector<type_name> & vec):ivec(vec)
{}
template <typename type_name> set<type_name>::set(const type_name* iptr,const int size)
{
for(int i=0;i<size;++i)
ivec.push_back(iptr[i]);
}
template<typename type_name> set<type_name> operator+(set<type_name>& lhs,set<type_name>& rhs)
{
std::vector<type_name> vec1(lhs.ivec),vec2(rhs.ivec),vec3;
for(std::vector<type_name>::iterator iter1=vec1.begin();iter1!=vec1.end();++iter1)
vec3.push_back(*iter1);
for(std::vector<type_name>::iterator iter2=vec2.begin();iter2!=vec2.end();++iter2)
{
bool flag(true);
for(std::vector<type_name>::iterator iter1=vec1.begin();iter1!=vec1.end();++iter1)
{
if(*iter1==*iter2)
flag=false;
}
if(flag)
vec3.push_back(*iter2);
}
set<std::string> obj_set(vec3);
return obj_set;


}
template<typename type_name> set<type_name> operator-(set<type_name>& lhs,set<type_name>& rhs)
{
std::vector<type_name> vec1(lhs.ivec),vec2(rhs.ivec),vec3;
for(std::vector<type_name>::iterator iter1=vec1.begin();iter1!=vec1.end();++iter1)
{
bool flag(true);
for(std::vector<type_name>::iterator iter2=vec2.begin();iter2!=vec2.end();++iter2)
{
if(*iter1==*iter2)
flag=false;
}
if(flag)
vec3.push_back(*iter1);
}
set<std::string> obj_set(vec3);
return obj_set;
}
template<typename type_name> set<type_name> operator&(set<type_name>& lhs,set<type_name>& rhs)
{
std::vector<type_name> vec1(lhs.ivec),vec2(rhs.ivec),vec3;
for(std::vector<type_name>::iterator iter1=vec1.begin();iter1!=vec1.end();++iter1)
{
bool flag(false);
for(std::vector<type_name>::iterator iter2=vec2.begin();iter2!=vec2.end();++iter2)
{
if(*iter1==*iter2)
flag=true;
}
if(flag)
vec3.push_back(*iter1);
}
set<std::string> obj_set(vec3);
return obj_set;


}
template<typename type_name> std::ostream & operator<<(std::ostream &os,set<type_name>& st)
{
std::vector<type_name> vec(st.ivec);
for(std::vector<type_name>::iterator iter=vec.begin();iter!=vec.end();++iter)
{
os<<*iter<<"\t";
}
return os;
}