NDK 数据结构之队列与栈等的实现_C/C++

NDK 数据结构之队列与栈等的实现

com_tz_ndk_cpp_NDKCpp.h

				?

									/* DO NOT EDIT THIS FILE - it is machine generated */

									#include <jni.h> 

									/* Header for class com_tz_ndk_cpp_NDKCpp */

									#ifndef _Included_com_tz_ndk_cpp_NDKCpp 

									#define _Included_com_tz_ndk_cpp_NDKCpp 

									#ifdef __cplusplus 

									extern "C" { 

									#endif 

									/* 

									 * Class:   com_tz_ndk_cpp_NDKCpp 

									 * Method:  callCppTest 

									 * Signature: ()V 

									 */

									JNIEXPORT void JNICALL Java_com_tz_ndk_cpp_NDKCpp_callCppQueue 

									 (JNIEnv *, jobject); 

									JNIEXPORT void JNICALL Java_com_tz_ndk_cpp_NDKCpp_callCppQueuePriority 

									    (JNIEnv *, jobject); 

									JNIEXPORT void JNICALL Java_com_tz_ndk_cpp_NDKCpp_callCppStack 

									    (JNIEnv *, jobject); 

									JNIEXPORT void JNICALL Java_com_tz_ndk_cpp_NDKCpp_callCppList 

									    (JNIEnv *, jobject); 

									JNIEXPORT void JNICALL Java_com_tz_ndk_cpp_NDKCpp_callCppListDelete 

									    (JNIEnv *, jobject); 

									JNIEXPORT void JNICALL Java_com_tz_ndk_cpp_NDKCpp_callCppListInsert 

									    (JNIEnv *, jobject); 

									JNIEXPORT void JNICALL Java_com_tz_ndk_cpp_NDKCpp_callCppSet 

									    (JNIEnv *, jobject); 

									JNIEXPORT void JNICALL Java_com_tz_ndk_cpp_NDKCpp_callCppSetReverse 

									    (JNIEnv *, jobject); 

									JNIEXPORT void JNICALL Java_com_tz_ndk_cpp_NDKCpp_callCppSetSort 

									    (JNIEnv *, jobject); 

									JNIEXPORT void JNICALL Java_com_tz_ndk_cpp_NDKCpp_callCppSetFind 

									    (JNIEnv *, jobject); 

									JNIEXPORT void JNICALL Java_com_tz_ndk_cpp_NDKCpp_callCppMultiSet 

									    (JNIEnv *, jobject); 

									JNIEXPORT void JNICALL Java_com_tz_ndk_cpp_NDKCpp_callCppMap 

									    (JNIEnv *, jobject); 

									JNIEXPORT void JNICALL Java_com_tz_ndk_cpp_NDKCpp_callCppMapDelete 

									    (JNIEnv *, jobject); 

									JNIEXPORT void JNICALL Java_com_tz_ndk_cpp_NDKCpp_callCppMapFind 

									    (JNIEnv *, jobject); 

									JNIEXPORT void JNICALL Java_com_tz_ndk_cpp_NDKCpp_callCppMultiMap 

									    (JNIEnv *, jobject); 

									JNIEXPORT void JNICALL Java_com_tz_ndk_cpp_NDKCpp_callCppVectorCopy 

									    (JNIEnv *, jobject); 

									#ifdef __cplusplus 

									} 

									#endif 

									#endif

com_tz_ndk_cpp_NDKCpp.cpp

				?

									#include <iostream> 

									#include <string> 

									#include <android/log.h> 

									#include "com_tz_ndk_cpp_NDKCpp.h" 

									using namespace std; 

									//1.C++语言：queue队列-基本使用 

									#include <queue> 

									JNIEXPORT void JNICALL Java_com_tz_ndk_cpp_NDKCpp_callCppQueue 

									    (JNIEnv *, jobject){ 

									  //初始化 

									  queue<char> q; 

									  //添加元素 

									  q.push('A'); 

									  q.push('B'); 

									  q.push('C'); 

									  //添加头部 

									//  q.front() = 'z'; 

									  //添加尾部 

									//  q.back() = 'D'; 

									  //删除操作 

									  while (!q.empty()){ 

									    __android_log_print(ANDROID_LOG_INFO,"main","值: %c",q.front()); 

									    //删除 

									    q.pop(); 

									  } 

									} 

									//2.C++语言：queue队列-优先级 

									JNIEXPORT void JNICALL Java_com_tz_ndk_cpp_NDKCpp_callCppQueuePriority 

									    (JNIEnv *, jobject){ 

									  //2.1 添加元素(默认是按照添加的顺序排列) 

									//  queue<int> q; 

									//  q.push(10); 

									//  q.push(50); 

									//  q.push(20); 

									//  q.push(5); 

									//  //打印 

									//  while (!q.empty()){ 

									//    __android_log_print(ANDROID_LOG_INFO,"main","值: %d",q.front()); 

									//    q.pop(); 

									//  } 

									  //2.2 最大值优先级队列(从大到小排列) 

									//  priority_queue<int> pq1; 

									//  pq1.push(10); 

									//  pq1.push(50); 

									//  pq1.push(20); 

									//  pq1.push(5); 

									//  while (!pq1.empty()){ 

									//    __android_log_print(ANDROID_LOG_INFO,"main","值: %d",pq1.top()); 

									//    pq1.pop(); 

									//  } 

									  //2.3 最小值优先级队列 

									  //注意：不同额编译器对语法检查有差别 

									  //在AS中进行NDK开发>>符号认为运算符,所以为了避免出现这样的情况，请用空格分离'> >' 

									  priority_queue<int,vector<int>,greater<int> > pq1; 

									  pq1.push(10); 

									  pq1.push(50); 

									  pq1.push(20); 

									  pq1.push(5); 

									  while (!pq1.empty()){ 

									    __android_log_print(ANDROID_LOG_INFO,"main","值: %d",pq1.top()); 

									    pq1.pop(); 

									  } 

									} 

									//3.C++语言：stack栈-基本使用 

									#include <stack> 

									JNIEXPORT void JNICALL Java_com_tz_ndk_cpp_NDKCpp_callCppStack 

									    (JNIEnv *, jobject){ 

									  stack<int> st; 

									  st.push(10); 

									  st.push(20); 

									  st.push(30); 

									  while (!st.empty()){ 

									    __android_log_print(ANDROID_LOG_INFO,"main","值: %d",st.top()); 

									    st.pop(); 

									  } 

									} 

									//4.C++语言：list-基本使用 

									#include <list> 

									JNIEXPORT void JNICALL Java_com_tz_ndk_cpp_NDKCpp_callCppList 

									    (JNIEnv *, jobject){ 

									  list<int> lt; 

									  //从头部添加 

									  lt.push_front(10); 

									  lt.push_front(20); 

									  lt.push_front(30); 

									  //从尾部添加 

									  lt.push_back(40); 

									  lt.push_back(50); 

									  lt.push_back(60); 

									  //循环遍历 

									  for (list<int>::iterator it = lt.begin() ; it != lt.end() ; it++){ 

									    __android_log_print(ANDROID_LOG_INFO,"main","值：%d",*it); 

									  } 

									  list<int>::iterator it = lt.begin(); 

									  //连续相加允许(++) 

									  //支持'++'、'--'运算符 

									  it++; 

									  it--; 

									  //注意：不支持间断 

									  //不支持'+'、'-'运算度 

									//  it = it - 1; 

									} 

									//5.C++语言：list-删除 

									JNIEXPORT void JNICALL Java_com_tz_ndk_cpp_NDKCpp_callCppListDelete 

									    (JNIEnv *, jobject){ 

									  list<int> lt; 

									  //从头部添加 

									  lt.push_front(10); 

									  lt.push_front(20); 

									  lt.push_front(30); 

									  //从尾部添加 

									  lt.push_back(40); 

									  lt.push_back(50); 

									  lt.push_back(60); 

									  //方式一 

									//  list<int>::iterator it = lt.begin(); 

									//  it++; 

									//  //删除：删除第二个元素 

									//  lt.erase(it); 

									  //方式二 

									  //删除第二个元素(直接根据内容删除) 

									//  lt.remove(20); 

									  //方式三:区间删除 

									  //开始位置 

									  list<int>::iterator it_begin = lt.begin(); 

									  //结束位置 

									  list<int>::iterator it_end = lt.begin(); 

									  it_end++; 

									  it_end++; 

									  //删除元素(如果已经被删除的元素不能够在删除) 

									  lt.erase(it_begin,it_end); 

									  //循环遍历 

									  for (list<int>::iterator it = lt.begin() ; it != lt.end() ; it++){ 

									    __android_log_print(ANDROID_LOG_INFO,"main","值：%d",*it); 

									  } 

									} 

									//6.C++语言：list-插入 

									JNIEXPORT void JNICALL Java_com_tz_ndk_cpp_NDKCpp_callCppListInsert 

									    (JNIEnv *, jobject){ 

									  list<int> lt; 

									  //从尾部添加 

									  lt.push_back(40); 

									  lt.push_back(50); 

									  lt.push_back(60); 

									  //插入 

									  lt.insert(lt.begin(),30); 

									  //循环遍历 

									  for (list<int>::iterator it = lt.begin() ; it != lt.end() ; it++){ 

									    __android_log_print(ANDROID_LOG_INFO,"main","值：%d",*it); 

									  } 

									} 

									//7.C++语言：set-基本使用(元素唯一)-默认从小到大排列 

									//特点一：元素唯一 

									//特点二：默认从小到大排列 

									#include <set> 

									JNIEXPORT void JNICALL Java_com_tz_ndk_cpp_NDKCpp_callCppSet 

									    (JNIEnv *, jobject){ 

									  set<int> st; 

									  st.insert(40); 

									  st.insert(10); 

									  st.insert(30); 

									  st.insert(20); 

									  //删除 

									  set<int>::iterator it = st.begin(); 

									  st.erase(it); 

									  for (set<int>::iterator it = st.begin() ; it != st.end() ; it++){ 

									    __android_log_print(ANDROID_LOG_INFO,"main","值：%d",*it); 

									  } 

									} 

									//8.C++语言：set-基本使用(元素唯一)-从大到小排列 

									//set<int,greater<int>> 

									JNIEXPORT void JNICALL Java_com_tz_ndk_cpp_NDKCpp_callCppSetReverse 

									    (JNIEnv *, jobject){ 

									  set<int,greater<int> > st; 

									  st.insert(40); 

									  st.insert(10); 

									  st.insert(30); 

									  st.insert(20); 

									  for (set<int>::iterator it = st.begin() ; it != st.end() ; it++){ 

									    __android_log_print(ANDROID_LOG_INFO,"main","值：%d",*it); 

									  } 

									} 

									//9.C++语言：set-自定义排序规则 

									//需求：根据学生的成绩进行排序 

									class Student{ 

									private: 

									  char* name; 

									  int score; 

									public: 

									  Student(char* name,int score){ 

									    this->name = name; 

									    this->score = score; 

									  } 

									  int getScore(){ 

									    return this->score; 

									  } 

									  void printStudent(){ 

									    __android_log_print(ANDROID_LOG_INFO,"main","姓名: %s, 成绩: %d",this->name,this->score); 

									  } 

									}; 

									//仿函数 

									struct Soft{ 

									  //方式一：不写常量 

									//  bool operator()(Student &left,Student &right){ 

									//    return left.getScore() < right.getScore(); 

									//  } 

									  //方式二：const修饰 

									  bool operator()(const Student &left,const Student &right){ 

									    //类型转换 

									    Student stu_left = const_cast<Student&>(left); 

									    Student stu_right = const_cast<Student&>(right); 

									    return stu_left.getScore() < stu_right.getScore(); 

									  } 

									}; 

									JNIEXPORT void JNICALL Java_com_tz_ndk_cpp_NDKCpp_callCppSetSort 

									    (JNIEnv *, jobject){ 

									  set<Student,Soft> st; 

									  st.insert(Student("小宇",50)); 

									  st.insert(Student("梦想",59)); 

									  st.insert(Student("song",55)); 

									  st.insert(Student("远方",58)); 

									  st.insert(Student("石桥中化妖",40)); 

									  for (set<Student>::iterator it = st.begin() ; it != st.end() ; it++){ 

									    Student stu = const_cast<Student&>(*it); 

									    stu.printStudent(); 

									  } 

									} 

									//10.C++语言：set-查找 

									JNIEXPORT void JNICALL Java_com_tz_ndk_cpp_NDKCpp_callCppSetFind 

									    (JNIEnv *, jobject){ 

									  set<int> st; 

									  st.insert(10); 

									  st.insert(20); 

									  st.insert(30); 

									  st.insert(40); 

									  st.insert(50); 

									  st.insert(60); 

									  st.insert(70); 

									  //方式一 

									  //查找等于30元素 

									  //st.find(2); 

									  //方式二 

									  //查找等于或者小余35元素 

									  //如果存在你输入的值30，那么就返回当前值30(例如：30) 

									  //如果不存在你查找的值31，那么返回大于31的最近的一个元素指针 

									  set<int>::iterator it_lower = st.lower_bound(31); 

									  __android_log_print(ANDROID_LOG_INFO,"main","查找结果: %d",*it_lower); 

									  //如果存在你查找的值30,那么就返回大于30最近的一个元素指针40 

									  //如果不存在你查找的值31，那么就返回大于31最近的一个元素的指针40 

									  set<int>::iterator it_upper = st.upper_bound(31); 

									  __android_log_print(ANDROID_LOG_INFO,"main","查找结果: %d",*it_upper); 

									  //方式三:既要返回最小也要最大 

									  pair<set<int>::iterator,set<int>::iterator> p = st.equal_range(30); 

									  //获取返回的元素 

									  __android_log_print(ANDROID_LOG_INFO,"main","小: %d",*p.first); 

									  __android_log_print(ANDROID_LOG_INFO,"main","大: %d",*p.second); 

									} 

									//11.C++语言：multiset-基本使用 

									//允许存储重复元素 

									//默认升序排列 

									JNIEXPORT void JNICALL Java_com_tz_ndk_cpp_NDKCpp_callCppMultiSet 

									    (JNIEnv *, jobject){ 

									  //升序 

									//  multiset<int> mst; 

									//  mst.insert(10); 

									//  mst.insert(20); 

									//  mst.insert(30); 

									//  mst.insert(10); 

									// 

									//  for (multiset<int>::iterator it = mst.begin() ; it != mst.end() ; it++){ 

									//    __android_log_print(ANDROID_LOG_INFO,"main","值: %d",*it); 

									//  } 

									  //降序 

									//  multiset<int,greater<int> > mst; 

									//  mst.insert(10); 

									//  mst.insert(20); 

									//  mst.insert(30); 

									//  mst.insert(10); 

									// 

									//  for (multiset<int>::iterator it = mst.begin() ; it != mst.end() ; it++){ 

									//    __android_log_print(ANDROID_LOG_INFO,"main","值: %d",*it); 

									//  } 

									  //自定义排序方式 

									  multiset<Student,Soft> mst; 

									  mst.insert(Student("小宇",50)); 

									  mst.insert(Student("梦想",59)); 

									  mst.insert(Student("song",55)); 

									  mst.insert(Student("远方",58)); 

									  mst.insert(Student("石桥中化妖",40)); 

									  mst.insert(Student("Dream",40)); 

									  for (multiset<Student>::iterator it = mst.begin() ; it != mst.end() ; it++){ 

									    Student stu = const_cast<Student&>(*it); 

									    stu.printStudent(); 

									  } 

									} 

									//12.C++语言：map-基本使用 

									#include <map> 

									#include <string> 

									JNIEXPORT void JNICALL Java_com_tz_ndk_cpp_NDKCpp_callCppMap 

									    (JNIEnv *, jobject){ 

									  map<int,string> mp; 

									  //方式一：插入数据pair 

									  mp.insert(pair<int,string>(01,"陈国军")); 

									  mp.insert(pair<int,string>(02,"Mr.Sunday")); 

									  mp.insert(pair<int,string>(03,"Studio")); 

									  mp.insert(pair<int,string>(04,"余祚宁")); 

									  //方式二：如果key存在，那么就不添加同时不覆盖，如果不存在，就添加 

									  pair<map<int,string>::iterator, bool> result = mp.insert(map<int,string>::value_type(04,"相约98")); 

									  if(result.second){ 

									    __android_log_print(ANDROID_LOG_INFO,"main","添加成功!"); 

									  }else{ 

									    __android_log_print(ANDROID_LOG_INFO,"main","已存在,添加失败!"); 

									  } 

									  //方式三： 

									  mp.insert(make_pair(05,"定定")); 

									  //方式四：如果key存在，重复添加会覆盖，如果不存在，那就直接添加 

									  mp[5] = "石桥中化妖"; 

									  mp[6] = "定定"; 

									  for (map<int,string>::iterator it = mp.begin() ; it != mp.end() ; it++){ 

									    //获取key:it->first 

									    __android_log_print(ANDROID_LOG_INFO,"main","key: %d",it->first); 

									    //获取value:it->second 

									    __android_log_print(ANDROID_LOG_INFO,"main","value: %s",it->second.c_str()); 

									  } 

									} 

									//13.C++语言：map-删除 

									JNIEXPORT void JNICALL Java_com_tz_ndk_cpp_NDKCpp_callCppMapDelete 

									    (JNIEnv *, jobject){ 

									  map<int,string> mp; 

									  mp.insert(pair<int,string>(01,"陈国军")); 

									  mp.insert(pair<int,string>(02,"Mr.Sunday")); 

									  mp.insert(pair<int,string>(03,"Studio")); 

									  mp.insert(pair<int,string>(04,"余祚宁")); 

									  //删除 

									  map<int,string>::iterator it = mp.begin(); 

									  mp.erase(it); 

									  //打印 

									  for (map<int,string>::iterator it = mp.begin() ; it != mp.end() ; it++){ 

									    //获取key:it->first 

									    __android_log_print(ANDROID_LOG_INFO,"main","key: %d",it->first); 

									    //获取value:it->second 

									    __android_log_print(ANDROID_LOG_INFO,"main","value: %s",it->second.c_str()); 

									  } 

									} 

									//14.C++语言：map-查找(equal_range) 

									JNIEXPORT void JNICALL Java_com_tz_ndk_cpp_NDKCpp_callCppMapFind 

									    (JNIEnv *, jobject){ 

									  map<int,string> mp; 

									  mp.insert(pair<int,string>(01,"陈国军")); 

									  mp.insert(pair<int,string>(02,"Mr.Sunday")); 

									  mp.insert(pair<int,string>(03,"Studio")); 

									  mp.insert(pair<int,string>(04,"余祚宁")); 

									  //获取大于或者等于2的元素 

									  pair<map<int,string>::iterator,map<int,string>::iterator> p = mp.equal_range(2); 

									  //判断是否存在元素 

									  if(p.first != mp.end()){ 

									    //等于2 

									    //获取key:it->first 

									    __android_log_print(ANDROID_LOG_INFO,"main","key: %d",p.first->first); 

									    //获取value:it->second 

									    __android_log_print(ANDROID_LOG_INFO,"main","value: %s",p.first->second.c_str()); 

									    //大于2元素 

									    //获取key:it->first 

									    __android_log_print(ANDROID_LOG_INFO,"main","key: %d",p.second->first); 

									    //获取value:it->second 

									    __android_log_print(ANDROID_LOG_INFO,"main","value: %s",p.second->second.c_str()); 

									  } 

									} 

									//15.C++语言：multimap-一对多 

									//需求：一个用户对应多个订单 

									class Order{ 

									private: 

									  char* name; 

									  int num; 

									public: 

									  Order(char* name,int num){ 

									    this->name = name; 

									    this->num = num; 

									  } 

									  void printOrder(){ 

									    __android_log_print(ANDROID_LOG_INFO,"main","订单名称：%s, 订单号：%d",this->name,this->num); 

									  } 

									}; 

									JNIEXPORT void JNICALL Java_com_tz_ndk_cpp_NDKCpp_callCppMultiMap 

									    (JNIEnv *, jobject){ 

									  multimap<string,Order> mst; 

									  mst.insert(make_pair("陈国军",Order("男士外套",01))); 

									  mst.insert(make_pair("陈国军",Order("户外跑鞋",02))); 

									  mst.insert(make_pair("梦想",Order("女士外套",03))); 

									  mst.insert(make_pair("梦想",Order("女士高跟鞋",02))); 

									  mst.insert(make_pair("Dream",Order("女士纱衣",03))); 

									  mst.insert(make_pair("Dream",Order("女士布鞋",02))); 

									  mst.insert(make_pair("Dream",Order("女士外套",02))); 

									  mst.insert(make_pair("Dream",Order("女士裤子",02))); 

									  //遍历 

									//  for (multimap<string,Order>::iterator it = mst.begin() ; it != mst.end() ; it++){ 

									//    //获取key:it->first 

									//    __android_log_print(ANDROID_LOG_INFO,"main","key: %s",it->first.c_str()); 

									//    //获取value:it->second 

									//    Order order = const_cast<Order&>(it->second); 

									//    order.printOrder(); 

									//  } 

									  //需求：只获取"梦想"订单 

									  //获取订单的数量 

									  int count = mst.count("梦想"); 

									  //打印"梦想"订单:找到 

									  multimap<string,Order>::iterator it = mst.find("梦想"); 

									  //循环遍历打印 

									  //计数 

									  int i = 0; 

									  while (it != mst.end() && i < count){ 

									    __android_log_print(ANDROID_LOG_INFO,"main","key: %s",it->first.c_str()); 

									    Order order = const_cast<Order&>(it->second); 

									    order.printOrder(); 

									    i++; 

									    it++; 

									  } 

									} 

									//16.C++语言：vector-浅拷贝和深拷贝 

									class User{ 

									private: 

									  char* name; 

									  int age; 

									public: 

									  //浅拷贝(默认就是浅拷贝) 

									  User(char* name,int age){ 

									    //动态分配内存 

									    this->name = new char[strlen(name)+1]; 

									    strcpy(this->name,name); 

									    this->age = age; 

									  } 

									  ~User(){ 

									    if(this->name != NULL){ 

									      delete[] this->name; 

									      this->name = NULL; 

									      this->age = 0; 

									    } 

									  } 

									  void printUser(){ 

									    __android_log_print(ANDROID_LOG_INFO,"main","名称：%s, 年龄: %d",this->name,this->age); 

									  } 

									  //深拷贝 

									  User(const User &user){ 

									    //先释放内存 

									    if(this->name != NULL){ 

									      delete[] this->name; 

									      this->name = NULL; 

									      this->age = 0; 

									    } 

									    //动态分配内存 

									    this->name = new char[strlen(user.name)+1]; 

									    strcpy(this->name,user.name); 

									    this->age = user.age; 

									  } 

									  User& operator=(User &user){ 

									    if(this->name != NULL){ 

									      delete[] this->name; 

									      this->name = NULL; 

									      this->age = 0; 

									    } 

									    //动态分配内存 

									    this->name = new char[strlen(user.name)+1]; 

									    strcpy(this->name,user.name); 

									    this->age = user.age; 

									    return *this; 

									  } 

									}; 

									//class User{ 

									//private: 

									//  string* name; 

									//  int age; 

									//public: 

									//  //浅拷贝(默认就是浅拷贝) 

									//  User(string name,int age){ 

									//    //动态分配内存 

									//    this->name = new string(const_cast<string&>(name)); 

									//    this->age = age; 

									//  } 

									//  ~User(){ 

									//    if(this->name != NULL){ 

									//      delete this->name; 

									//      this->name = NULL; 

									//      this->age = 0; 

									//    } 

									//  } 

									//  void printUser(){ 

									//    __android_log_print(ANDROID_LOG_INFO,"main","名称：%s, 年龄: %d",this->name,this->age); 

									//  } 

									// 

									//  //深拷贝 

									//  User(const User &user){ 

									//    //先释放内存 

									//    if(this->name != NULL){ 

									//      delete this->name; 

									//      this->name = NULL; 

									//      this->age = 0; 

									//    } 

									//    //动态分配内存 

									//    this->name = new string(const_cast<string&>(user.name)); 

									//    this->age = age; 

									//  } 

									// 

									//  User& operator=(User &user){ 

									//    if(this->name != NULL){ 

									//      delete this->name; 

									//      this->name = NULL; 

									//      this->age = 0; 

									//    } 

									//    //动态分配内存 

									//    this->name = new string(const_cast<string&>(user.name)); 

									//    this->age = age; 

									//    return *this; 

									//  } 

									// 

									////}; 

									JNIEXPORT void JNICALL Java_com_tz_ndk_cpp_NDKCpp_callCppVectorCopy 

									    (JNIEnv *, jobject){ 

									  vector<User> vt; 

									  User user("石桥中化妖",18); 

									  //实参作为形参，需要调用拷贝函数，然后默认是浅拷贝 

									  vt.push_back(user); 

									  //解决方案：深拷贝 

									  for (vector<User>::iterator it = vt.begin() ; it != vt.end() ; it++){ 

									    User order = const_cast<User&>(*it); 

									    order.printUser(); 

									  } 

									  //作业：string如何深拷贝(稍微麻烦一点) 

									}