自学教程：C++ DBG_START_METH函数代码示例

 void CompoundVector::ElementWiseMinImpl(const Vector& x) {   DBG_START_METH("CompoundVector::ElementWiseMinImpl", dbg_verbosity);   DBG_ASSERT(vectors_valid_);   const CompoundVector* comp_x = static_cast<const CompoundVector*>(&x);   DBG_ASSERT(dynamic_cast<const CompoundVector*>(&x));   DBG_ASSERT(NComps() == comp_x->NComps());   for (Index i=0; i<NComps(); i++) {     Comp(i)->ElementWiseMin(*comp_x->GetComp(i));   } }

 bool DenseGenSchurDriver::SchurFactorize() {   DBG_START_METH("DenseGenSchurDriver::SchurFactorize", dbg_verbosity);   /* This function is the very same as the one in DenseGenSchurDriver */   bool retval;   if (IsValid(S_)) {     retval = S_->ComputeLUFactorInPlace();     return retval;   }   return true; }

  bool CachedResults<T>::GetCachedResult1Dep(T& retResult, const TaggedObject* dependent1)  {#ifdef IP_DEBUG_CACHE    DBG_START_METH("CachedResults<T>::GetCachedResult1Dep", dbg_verbosity);#endif    std::vector<const TaggedObject*> dependents(1);    dependents[0] = dependent1;    return GetCachedResult(retResult, dependents);  }

 SmartPtr<const Vector> StandardScalingBase::unapply_vector_scaling_x(   const SmartPtr<const Vector>& v) {   DBG_START_METH("NLPScalingObject::unapply_vector_scaling_x", dbg_verbosity);   if (IsValid(dx_)) {     return ConstPtr(unapply_vector_scaling_x_NonConst(v));   }   else {     return v;   } }

  inline  void Subject::Notify(Observer::NotifyType notify_type) const  {#ifdef IP_DEBUG_OBSERVER    DBG_START_METH("Subject::Notify", dbg_verbosity);#endif    std::vector<Observer*>::iterator iter;    for (iter = observers_.begin(); iter != observers_.end(); iter++) {      (*iter)->ProcessNotification(notify_type, this);    }  }

  MumpsSolverInterface::~MumpsSolverInterface()  {    DBG_START_METH("MumpsSolverInterface::~MumpsSolverInterface()",                   dbg_verbosity);    DMUMPS_STRUC_C* mumps_ = (DMUMPS_STRUC_C*)mumps_ptr_;    mumps_->job = -2; //terminate mumps    dmumps_c(mumps_);    MPI_Finalize();    delete [] mumps_->a;    delete mumps_;  }

  bool CGPenaltyLSAcceptor::RestoreBestPoint()  {    DBG_START_METH("CGPenaltyLSAcceptor::RestoreBestPoint",                   dbg_verbosity);    if (!IsValid(best_iterate_)) {      return false;    }    SmartPtr<IteratesVector> prev_iterate = best_iterate_->MakeNewContainer();    IpData().set_trial(prev_iterate);    return true;  }

  IterativeWsmpSolverInterface::~IterativeWsmpSolverInterface()  {    DBG_START_METH("IterativeWsmpSolverInterface::~IterativeWsmpSolverInterface()",                   dbg_verbosity);    // Clear WSMP's memory    F77_FUNC_(wsmp_clear,WSMP_CLEAR)();    delete[] IPARM_;    delete[] DPARM_;    delete[] a_;  }

Ma57TSolverInterface::~Ma57TSolverInterface(){    DBG_START_METH("Ma57TSolverInterface::~Ma57TSolverInterface()",                   dbg_verbosity);    delete [] a_;    delete [] wd_fact_;    delete [] wd_ifact_;    delete [] wd_iwork_;    delete [] wd_keep_;}

 SensAlgorithm::~SensAlgorithm() {   DBG_START_METH("SensAlgorithm::~SensAlgorithm", dbg_verbosity);   if (NULL != DirectionalD_X_) delete [] DirectionalD_X_ ;   if (NULL != DirectionalD_L_) delete [] DirectionalD_L_ ;   if (NULL != DirectionalD_Z_U_) delete [] DirectionalD_Z_U_ ;   if (NULL != DirectionalD_Z_L_) delete [] DirectionalD_Z_L_ ;   if (NULL != SensitivityM_X_) delete [] SensitivityM_X_ ;   if (NULL != SensitivityM_L_) delete [] SensitivityM_L_ ;   if (NULL != SensitivityM_Z_U_) delete [] SensitivityM_Z_U_ ;   if (NULL != SensitivityM_Z_L_) delete [] SensitivityM_Z_L_ ; }

 Number PiecewisePenalty::BiggestBarr() {   DBG_START_METH("PiecewisePenalty::BiggestBarr", dbg_verbosity);   DBG_ASSERT(!IsPiecewisePenaltyListEmpty());   Number value = -1e20;   if (PiecewisePenalty_list_.size() > 0) {     std::vector<PiecewisePenEntry>::iterator iter;     iter = PiecewisePenalty_list_.end();     iter--;     value = iter->barrier_obj;   }   return value; }

  bool TSymDependencyDetector::DetermineDependentRows(    Index n_rows, Index n_cols, Index n_jac_nz, Number* jac_c_vals,    Index* jac_c_iRow, Index* jac_c_jCol, std::list<Index>& c_deps)  {    DBG_START_METH("TSymDependencyDetector::DetermineDependentRows",                   dbg_verbosity);    ESymSolverStatus retval =      tsym_linear_solver_->DetermineDependentRows(n_rows, n_cols, n_jac_nz,          jac_c_vals, jac_c_iRow,          jac_c_jCol, c_deps);    return (retval == SYMSOLVER_SUCCESS);  }

  bool IndexPCalculator::InitializeImpl(const OptionsList& options,					const std::string& prefix)  {    DBG_START_METH("IndexPCalculator::InitializeImpl", dbg_verbosity);    SmartPtr<const IteratesVector> iv = IpData().curr();    nrows_ = 0;    for (Index i=0; i<iv->NComps(); ++i) {      nrows_+=iv->GetComp(i)->Dim();    }    data_A()->Print(Jnlst(),J_VECTOR,J_USER1,"PCalc SchurData");    return true;  }

  WsmpSolverInterface::WsmpSolverInterface()      :      a_(NULL),      negevals_(-1),      initialized_(false),      PERM_(NULL),      INVP_(NULL)  {    DBG_START_METH("WsmpSolverInterface::WsmpSolverInterface()",dbg_verbosity);    IPARM_ = new ipfint[64];    DPARM_ = new double[64];  }

 SmartPtr<Vector> StandardScalingBase::unapply_vector_scaling_x_NonConst(   const SmartPtr<const Vector>& v) {   DBG_START_METH("StandardScalingBase::unapply_vector_scaling_x_NonConst",                  dbg_verbosity);   SmartPtr<Vector> unscaled_x = v->MakeNewCopy();   if (IsValid(dx_)) {     unscaled_x->ElementWiseDivide(*dx_);   }   else {     DBG_PRINT((1, "Creating copy in unapply_vector_scaling_x_NonConst!"));   }   return unscaled_x; }

  bool AmplTNLP::eval_g(Index n, const Number* x, bool new_x, Index m, Number* g)  {    DBG_START_METH("AmplTNLP::eval_g", dbg_verbosity);    DBG_DO(ASL_pfgh* asl = asl_);    DBG_ASSERT(n == n_var);    DBG_ASSERT(m == n_con);    if (!apply_new_x(new_x, n, x)) {      return false;    }    return internal_conval(x, m, g);  }