【Hackathon 6th Fundable Projects 2 No.22】cppcoreguidelines-pro-type-member-init_4-part

paddle/common/ddim.cc

@@ -20,7 +20,7 @@ namespace common {
 
 DDim::DDim() : rank_(-1) { dim_[0] = 0; }
 
-DDim::DDim(const DDim& ddim) : dim_() { CopyFrom(ddim); }
+DDim::DDim(const DDim& ddim) : dim_(), rank_(-1) { CopyFrom(ddim); }
 
 DDim::DDim(const int* d, int n) : rank_(n) {
   dynamic_dim_assign(d, dim_.GetMutable(), n);

paddle/fluid/distributed/fleet_executor/fleet_executor.cc

@@ -31,7 +31,7 @@
 namespace paddle {
 namespace distributed {
 
-FleetExecutor::FleetExecutor(const std::string& exe_desc_str) {
+FleetExecutor::FleetExecutor(const std::string& exe_desc_str) : carrier_ids_() {
   bool parse_flag = exe_desc_.ParseFromString(exe_desc_str);
   PADDLE_ENFORCE(parse_flag,
                  platform::errors::PreconditionNotMet(
@@ -42,7 +42,7 @@ FleetExecutor::FleetExecutor(const std::string& exe_desc_str) {
 }
 
 FleetExecutor::FleetExecutor(const FleetExecutorDesc& exe_desc)
-    : exe_desc_(exe_desc) {
+    : exe_desc_(exe_desc), carrier_ids_() {
   // Message bus will be created and inited only once
   GlobalVal<MessageBus>::Create();
   InitMessageBus();

paddle/fluid/framework/details/eager_deletion_op_handle.cc

@@ -43,7 +43,8 @@ EagerDeletionOpHandle::EagerDeletionOpHandle(
       scope_idx_(scope_idx),
       place_(place),
       var_infos_(vars.begin(), vars.end()),
-      gc_(gc) {
+      gc_(gc),
+      vars_() {
 #if defined(PADDLE_WITH_CUDA) || defined(PADDLE_WITH_HIP)
   if (platform::is_gpu_place(place)) {
     dev_ctx_ = reinterpret_cast<phi::GPUContext *>(

paddle/fluid/framework/details/fetch_op_handle.cc

@@ -33,6 +33,7 @@ FetchOpHandle::FetchOpHandle(ir::Node *node,
       offset_(offset),
       local_scopes_(local_scopes),
       local_exec_scopes_(local_exec_scopes),
+      tensors_(),
       return_merged_(return_merged) {}
 
 FetchOpHandle::~FetchOpHandle() = default;

paddle/fluid/framework/executor.cc

@@ -44,7 +44,7 @@ int kProgramId = -1;
 
 ExecutorPrepareContext::ExecutorPrepareContext(
     const framework::ProgramDesc& prog, size_t block_id)
-    : prog_(prog), block_id_(block_id) {}
+    : prog_(prog), block_id_(block_id), ops_(), unused_vars_() {}
 
 void ExecutorPrepareContext::PrepareUnusedVars(
     const std::vector<std::string>& keep_vars, bool force_disable_gc) {

paddle/fluid/framework/ir/memory_optimize_pass/op_graph_view.cc

@@ -26,7 +26,8 @@ namespace paddle {
 namespace framework {
 namespace ir {
 
-OpGraphView::OpGraphView(const std::vector<details::OpHandleBase *> &ops) {
+OpGraphView::OpGraphView(const std::vector<details::OpHandleBase *> &ops)
+    : preceding_ops_(), pending_ops_() {
   Build(ops);
 }
 

paddle/fluid/framework/new_executor/interpreter/dependency_builder.cc

@@ -559,7 +559,7 @@ void DependencyBuilder::UpdateVarMinRwOp(
 /// ======================== ///
 ///        For new ir        ///
 /// ======================== ///
-PirDependencyBuilder::PirDependencyBuilder() {
+PirDependencyBuilder::PirDependencyBuilder() : instructions_() {
   is_build_ = false;
   op_downstream_map_ = std::make_shared<std::map<size_t, std::set<size_t>>>();
   op_happens_before_ = std::make_shared<std::vector<std::vector<bool>>>();

paddle/fluid/framework/new_executor/interpreter/interpreter_util.cc

@@ -117,10 +117,9 @@ const std::vector<WorkQueueOptions> ConstructWorkQueueOptions(
 AsyncWorkQueue::AsyncWorkQueue(size_t host_num_threads,
                                size_t device_num_threads,
                                EventsWaiter* waiter)
-    : host_num_thread_(host_num_threads) {
-  queue_group_ = CreateWorkQueueGroup(
-      ConstructWorkQueueOptions(host_num_threads, device_num_threads, waiter));
-}
+    : host_num_thread_(host_num_threads),
+      queue_group_(CreateWorkQueueGroup(ConstructWorkQueueOptions(
+          host_num_threads, device_num_threads, waiter))) {}
 
 void AsyncWorkQueue::AddTask(const OpFuncType& op_func_type,
                              std::function<void()> fn) {

paddle/fluid/framework/new_executor/interpretercore.cc

@@ -41,7 +41,8 @@ namespace framework {
 InterpreterCore::InterpreterCore(const platform::Place& place,
                                  const BlockDesc& block,
                                  framework::Scope* scope,
-                                 const ExecutionConfig& execution_config) {
+                                 const ExecutionConfig& execution_config)
+    : impl_(nullptr), fetch_var_names_() {
   VLOG(4) << "InterpreterCore(): " << this << " on " << place;
   impl_ = std::make_unique<ProgramInterpreter>(
       place, block, scope, execution_config);
@@ -52,7 +53,8 @@ InterpreterCore::InterpreterCore(
     const std::vector<std::string>& fetch_var_names,
     const ::pir::Block* ir_block,
     framework::Scope* scope,
-    const ExecutionConfig& execution_config) {
+    const ExecutionConfig& execution_config)
+    : impl_(nullptr), fetch_var_names_() {
   VLOG(4) << "InterpreterCore(): " << this << " on " << place;
   impl_ = std::make_unique<PirInterpreter>(
       place, fetch_var_names, ir_block, scope, execution_config);

paddle/fluid/framework/parallel_executor.cc

@@ -77,7 +77,18 @@ class ParallelExecutorPrivate {
  public:
   ParallelExecutorPrivate(const std::vector<platform::Place> &places,
                           Scope *global_scope)
-      : places_(places), global_scope_(global_scope) {
+      : places_(places),
+        local_scopes_(),
+        local_exec_scopes_(),
+        global_scope_(global_scope),
+        executor_(nullptr),
+        is_persistable_(),
+        own_local_scope_(false),
+        use_device_(DeviceType::CPU),
+        use_all_reduce_(false),
+        nranks_(0),
+        mem_opt_var_infos_(),
+        gcs_() {
     if (!FLAGS_pe_profile_fname.empty()) {
       std::call_once(gProfileOnce, [] {
 #ifdef WITH_GPERFTOOLS
@@ -674,7 +685,9 @@ ParallelExecutor::ParallelExecutor(const std::vector<platform::Place> &places,
                                    const ExecutionStrategy &exec_strategy,
                                    const BuildStrategy &build_strategy,
                                    ir::Graph *graph)
-    : member_(new ParallelExecutorPrivate(places, scope)) {
+    : member_(new ParallelExecutorPrivate(places, scope)),
+      async_graphs_(),
+      var_infos_() {
   PADDLE_ENFORCE_EQ(!places.empty(),
                     true,
                     platform::errors::Unavailable(
@@ -747,7 +760,9 @@ ParallelExecutor::ParallelExecutor(const platform::Place &place,
                                    const ExecutionStrategy &exec_strategy,
                                    const BuildStrategy &build_strategy,
                                    ir::Graph *graph)
-    : member_(new ParallelExecutorPrivate({place}, scope)) {
+    : member_(new ParallelExecutorPrivate({place}, scope)),
+      async_graphs_(),
+      var_infos_() {
   // Initialize necessary info of member_ with strategy.
   InitExecutorPrivateMemberInfo(exec_strategy,
                                 build_strategy,

paddle/fluid/framework/scope.cc

@@ -28,7 +28,7 @@ COMMON_DECLARE_bool(eager_delete_scope);
 
 namespace paddle {
 namespace framework {
-Scope::Scope() = default;
+Scope::Scope() : vars_(), kids_() {}
 Scope::~Scope() { DropKids(); }  // NOLINT
 
 Scope& Scope::NewScope() const {

paddle/fluid/imperative/amp_auto_cast.cc

@@ -120,9 +120,7 @@ OpSupportedInfos(const std::string& place,
 }
 
 AutoCastGuard::AutoCastGuard(std::shared_ptr<AmpAttrs> state, AmpLevel level)
-    : state_(state) {
-  pre_amp_level_ = state_->GetAmpLevel();
-
+    : state_(state), pre_amp_level_(state_->GetAmpLevel()) {
   if (pre_amp_level_ != level) {
     state_->SetAmpLevel(level);
   }

paddle/fluid/inference/tensorrt/test_tensorrt.cc

@@ -45,11 +45,8 @@ class Logger : public nvinfer1::ILogger {
 
 class ScopedWeights {
  public:
-  explicit ScopedWeights(float value) : value_(value) {
-    w.type = nvinfer1::DataType::kFLOAT;
-    w.values = &value_;
-    w.count = 1;
-  }
+  explicit ScopedWeights(float value)
+      : value_(value), w{nvinfer1::DataType::kFLOAT, &value_, 1} {}
   const nvinfer1::Weights& get() { return w; }
 
  private:

paddle/fluid/pir/dialect/operator/ir/op_dialect.cc

@@ -437,6 +437,8 @@ class IdManager {
     return instance;
   }
 
+  IdManager() : ids_() {}
+
   ~IdManager() {
     for (auto id : ids_) {
       delete id;

paddle/fluid/pybind/graph.cc

@@ -229,7 +229,7 @@ void BindNode(py::module *m) {
 
 class PYBIND11_HIDDEN PassAttrGetterSetterRegistry {
  private:
-  PassAttrGetterSetterRegistry() = default;
+  PassAttrGetterSetterRegistry() : getter_setter_map_() {}
   DISABLE_COPY_AND_ASSIGN(PassAttrGetterSetterRegistry);
 
   using Getter = std::function<py::object(const framework::ir::Pass & /*pass*/,

test/cpp/fluid/test_common_infer_shape_functions.cc

@@ -61,7 +61,7 @@ class DygraphInferShapeTest {
   imperative::NameVarBaseMap outs_;
   framework::AttributeMap attrs_;
   std::string op_type_;
-  std::map<std::string, framework::DDim> expected_dims_;
+  std::map<std::string, framework::DDim> expected_dims_ = {};
 };
 }  // namespace details
 

test/cpp/inference/api/mkldnn_quantizer_tester.cc

@@ -25,7 +25,7 @@ namespace paddle {
 
 class MkldnnQuantizerTest : public testing::Test {
  public:
-  MkldnnQuantizerTest() {
+  MkldnnQuantizerTest() : predictor(nullptr), mkldnn_quantizer(nullptr) {
     AnalysisConfig config(FLAGS_dirname);
     predictor = CreatePaddlePredictor(config);
     auto* predictor_p = static_cast<AnalysisPredictor*>(predictor.get());

test/deprecated/cpp/inference/api/analyzer_paddle_tensor_tester.cc

@@ -25,6 +25,7 @@ namespace inference {
 struct Record {
   std::vector<float> data;
   std::vector<int32_t> shape;
+  Record() : data(), shape() {}
 };
 
 Record ProcessALine(const std::string &line) {

test/deprecated/cpp/inference/api/analyzer_rnn2_tester.cc

@@ -27,9 +27,13 @@ struct DataRecord {
   size_t num_samples;  // total number of samples
   size_t batch_iter{0};
   size_t batch_size{1};
-  DataRecord() = default;
+  DataRecord() : link_step_data_all(), lod(), rnn_link_data(), num_samples(0) {}
   explicit DataRecord(const std::string &path, int batch_size = 1)
-      : batch_size(batch_size) {
+      : link_step_data_all(),
+        lod(),
+        rnn_link_data(),
+        num_samples(0),
+        batch_size(batch_size) {
     Load(path);
   }
   DataRecord NextBatch() {