Protobuf使用不当导致的程序内存上涨问题

run_res_t run();

private:

     proto::feature_t   _merged_data;    // contains the merged feature

}； // class ModuleA

//  in cpp file

run_res_t ModuleA::reset() {

    // the following reset op-s are for feature merging

    _merged_data.Clear();

}

run_res_t FeatureModule::run(){

    fc_list_t* p_mg_fc_list = _merged_data.mutable_fea_cluster_list();

    proto::fea_cluster_t* p_mg_fc = p_mg_fc_list->Add();

    p_mg_fc->set_fea_cluster_type(static_cast <

            proto::fea_cluster_t_fea_cluster_type_t >( DEMO_TYPE));

    demo_fea_list_t* p_mg_demo_fea_list = p_mg_fc->mutable_demo_fea_list();

    proto::demo_fea_t* p_mg_demo = p_mg_demo_fea_list->Add();

    p_mg_demo->set_type(DEMO_TYPE);

     // 此处省略50行

}

run_res_t run();

private:

      proto::feature_t         _merged_data;    // contains the merged feature

}； // class ModuleA

//  in cpp file

run_res_t ModuleA::reset() {

// the following reset op-s are for feature merging

  //_merged_data.Clear();

  _merged_data.reset(new(std::nothrow)proto::feature_t);

  if  (!_merged_data.get()) {

     FATAL_LOG("new fea_header_t failed");

     return  RUN_ERROR;

  }

}

  for  (int  i = 0; i < fields.size(); i++) {

    reflection->ClearField(message, fields[i]);

  }

  reflection->MutableUnknownFields(message)->Clear();

}

//ClearField函数的实现

void  GeneratedMessageReflection::ClearField(

    Message* message,  const  FieldDescriptor* field)  const  {

  USAGE_CHECK_MESSAGE_TYPE(ClearField);

  if  (field->is_extension()) {

    MutableExtensionSet(message)->ClearExtension(field->number());

  }  else  if  (!field->is_repeated()) {   // 如果不是数组，也就是基础类型

    if  (HasBit(*message, field)) {

      ClearBit(message, field);

      // We need to set the field back to its default value.

      switch  (field->cpp_type()) {

#define CLEAR_TYPE(CPPTYPE, TYPE)                                           

        case  FieldDescriptor::CPPTYPE_##CPPTYPE:                            

          *MutableRaw<TYPE>(message, field) =                               

            field->default_value_##TYPE();                                  

          break;

        CLEAR_TYPE(INT32  , int32 );   // 对基础类型设置为默认值

        CLEAR_TYPE(INT64  , int64 );

        CLEAR_TYPE(UINT32, uint32);

        CLEAR_TYPE(UINT64, uint64);

        CLEAR_TYPE(FLOAT  ,  float  );

        CLEAR_TYPE(DOUBLE,  double);

        CLEAR_TYPE(BOOL   ,  bool   );

#undef CLEAR_TYPE

        case  FieldDescriptor::CPPTYPE_ENUM:   // 处理枚举类型

          *MutableRaw<int>(message, field) =

            field->default_value_enum()->number();

          break;

        case  FieldDescriptor::CPPTYPE_STRING: {

          switch  (field->options().ctype()) {

            default:   // TODO(kenton):  Support other string reps.

            case  FieldOptions::STRING:

              const  string* default_ptr = DefaultRaw<const  string*>(field);

              string** value = MutableRaw<string*>(message, field);

              if  (*value != default_ptr) {

                if  (field->has_default_value()) {   // 如果有默认值，则设置为默认值

                  (*value)->assign(field->default_value_string());

                }  else  {

                  (*value)->clear();   // 否则设置清理数据

                }

              }

              break;

          }

          break;

        }

        case  FieldDescriptor::CPPTYPE_MESSAGE:

          (*MutableRaw<Message*>(message, field))->Clear();

          break;

      }

    }

  }  else  {

    switch  (field->cpp_type()) {

#define HANDLE_TYPE(UPPERCASE, LOWERCASE)                                    

      case  FieldDescriptor::CPPTYPE_##UPPERCASE :                            

        MutableRaw<RepeatedField<LOWERCASE> >(message, field)->Clear();      

        break

      HANDLE_TYPE(  INT32,  int32);

      HANDLE_TYPE(  INT64,  int64);

      HANDLE_TYPE(UINT32, uint32);

      HANDLE_TYPE(UINT64, uint64);

      HANDLE_TYPE(DOUBLE,  double);

      HANDLE_TYPE(  FLOAT,   float);

      HANDLE_TYPE(   BOOL,    bool);

      HANDLE_TYPE(  ENUM,     int);

#undef HANDLE_TYPE

      case  FieldDescriptor::CPPTYPE_STRING: {

        switch  (field->options().ctype()) {

          default:   // TODO(kenton):  Support other string reps.

          case  FieldOptions::STRING:

            MutableRaw<RepeatedPtrField<string> >(message, field)->Clear();

            break;

        }

        break;

      }

      case  FieldDescriptor::CPPTYPE_MESSAGE: {

        // We don't know which subclass of RepeatedPtrFieldBase the type is,

        // so we use RepeatedPtrFieldBase directly.

        MutableRaw<RepeatedPtrFieldBase>(message, field)

            ->Clear<GenericTypeHandler<Message> >();

        break;

      }

    }

  }

}