!8500 [MSLITE][Develop] fix code check

From: @sunsuodong
Reviewed-by: @zhanghaibo5,@zhang_xue_tong
Signed-off-by: @zhang_xue_tong

mindspore/lite/src/ops/abs.h

@@ -27,13 +27,12 @@ namespace mindspore {
 namespace lite {
 class Abs : public ArithmeticSelf {
  public:
+  Abs() = default;
+  ~Abs() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(Abs, ArithmeticSelf);
-  Abs() = default;
   explicit Abs(schema::PrimitiveT *primitive) : ArithmeticSelf(primitive) {}
 #else
-  Abs() = default;
-
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
 };

mindspore/lite/src/ops/activation.h

@@ -26,9 +26,10 @@ namespace mindspore {
 namespace lite {
 class Activation : public PrimitiveC {
  public:
+  Activation() = default;
+  ~Activation() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(Activation, PrimitiveC);
-  Activation() = default;
   explicit Activation(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
   int UnPackAttr(const Primitive &prim, const std::vector<AnfNodePtr> &inputs) override;
   void SetType(int type);
@@ -36,8 +37,6 @@ class Activation : public PrimitiveC {
   void SetMinVal(float minVal);
   void SetMaxVal(float maxVal);
 #else
-  Activation() = default;
-
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
   int GetType() const;

mindspore/lite/src/ops/activation_grad.h

@@ -28,16 +28,15 @@ namespace mindspore {
 namespace lite {
 class ActivationGrad : public PrimitiveC {
  public:
+  ActivationGrad() = default;
+  ~ActivationGrad() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(ActivationGrad, PrimitiveC);
-  ActivationGrad() = default;
   explicit ActivationGrad(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
   void SetType(int type);
   void SetAlpha(float alpha);
   int UnPackAttr(const Primitive &prim, const std::vector<AnfNodePtr> &inputs) override;
 #else
-  ActivationGrad() = default;
-
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
   int GetType() const;

mindspore/lite/src/ops/adam.h

@@ -28,14 +28,13 @@ namespace mindspore {
 namespace lite {
 class Adam : public PrimitiveC {
  public:
+  Adam() = default;
+  ~Adam() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(Adam, PrimitiveC);
-  Adam() = default;
   explicit Adam(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
   int UnPackAttr(const Primitive &prim, const std::vector<AnfNodePtr> &inputs) override;
 #else
-  Adam() = default;
-
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
   int InferShape(std::vector<lite::Tensor *> inputs_, std::vector<lite::Tensor *> outputs_) override;

mindspore/lite/src/ops/add.h

@@ -26,15 +26,14 @@ namespace mindspore {
 namespace lite {
 class Add : public Arithmetic {
  public:
+  Add() = default;
+  ~Add() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(Add, Arithmetic);
-  Add() = default;
   explicit Add(schema::PrimitiveT *primitive) : Arithmetic(primitive) {}
   int UnPackAttr(const Primitive &prim, const std::vector<AnfNodePtr> &inputs) override;
   void SetActivationType(int activation_type);
 #else
-  Add() = default;
-
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
   int GetActivationType() const;

mindspore/lite/src/ops/addn.h

@@ -26,15 +26,14 @@ namespace mindspore {
 namespace lite {
 class AddN : public PrimitiveC {
  public:
+  AddN() = default;
+  ~AddN() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(AddN, PrimitiveC);
-  AddN() = default;
   explicit AddN(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
   void SetN(int n);
   int UnPackAttr(const Primitive &prim, const std::vector<AnfNodePtr> &inputs) override;
 #else
-  AddN() = default;
-
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
   int InferShape(std::vector<lite::Tensor *> inputs_, std::vector<lite::Tensor *> outputs_) override;

mindspore/lite/src/ops/apply_momentum.h

@@ -28,14 +28,13 @@ namespace mindspore {
 namespace lite {
 class ApplyMomentum : public PrimitiveC {
  public:
+  ApplyMomentum() = default;
+  ~ApplyMomentum() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(ApplyMomentum, PrimitiveC);
-  ApplyMomentum() = default;
   explicit ApplyMomentum(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
   int UnPackAttr(const Primitive &prim, const std::vector<AnfNodePtr> &inputs) override;
 #else
-  ApplyMomentum() = default;
-
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
   int InferShape(std::vector<lite::Tensor *> inputs_, std::vector<lite::Tensor *> outputs_) override;

mindspore/lite/src/ops/argmax.h

@@ -27,9 +27,10 @@ namespace mindspore {
 namespace lite {
 class ArgMax : public PrimitiveC {
  public:
+  ArgMax() = default;
+  ~ArgMax() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(ArgMax, PrimitiveC);
-  ArgMax() = default;
   explicit ArgMax(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
   void SetAxis(int axis);
   void SetOutMaxValue(bool out_max_value);
@@ -37,8 +38,6 @@ class ArgMax : public PrimitiveC {
   void SetKeepDims(bool keep_dims);
   void SetAxisType(int axis_type);
 #else
-  ArgMax() = default;
-
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
   int InferShape(std::vector<lite::Tensor *> inputs_, std::vector<lite::Tensor *> outputs_) override;

mindspore/lite/src/ops/argmin.h

@@ -26,9 +26,10 @@ namespace mindspore {
 namespace lite {
 class ArgMin : public PrimitiveC {
  public:
+  ArgMin() = default;
+  ~ArgMin() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(ArgMin, PrimitiveC);
-  ArgMin() = default;
   explicit ArgMin(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
   void SetAxis(int axis);
   void SetOutMaxValue(bool out_max_value);
@@ -36,8 +37,6 @@ class ArgMin : public PrimitiveC {
   void SetKeepDims(bool keep_dims);
   void SetAxisType(int axis_type);
 #else
-  ArgMin() = default;
-
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
   int InferShape(std::vector<lite::Tensor *> inputs_, std::vector<lite::Tensor *> outputs_) override;

mindspore/lite/src/ops/arithmetic.h

@@ -27,13 +27,13 @@ namespace mindspore {
 namespace lite {
 class Arithmetic : public PrimitiveC {
  public:
+  Arithmetic() = default;
+  ~Arithmetic() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(Arithmetic, PrimitiveC);
-  Arithmetic() = default;
   explicit Arithmetic(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
 #else
   //  explicit Arithmetic(schema::Primitive *primitive) : PrimitiveC(primitive) {}
-  Arithmetic() = default;
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override {
     return RET_ERROR;
   }

mindspore/lite/src/ops/arithmetic_grad.h

@@ -27,13 +27,13 @@ namespace mindspore {
 namespace lite {
 class ArithmeticGrad : public PrimitiveC {
  public:
+  ArithmeticGrad() = default;
+  ~ArithmeticGrad() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(ArithmeticGrad, PrimitiveC);
-  ArithmeticGrad() = default;
   explicit ArithmeticGrad(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
 #else
   // explicit ArithmeticGrad(const schema::Primitive &primitive) : PrimitiveC(primitive) {}
-  ArithmeticGrad() = default;
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override {
     return RET_ERROR;
   }

mindspore/lite/src/ops/arithmetic_self.h

@@ -25,13 +25,13 @@ namespace mindspore {
 namespace lite {
 class ArithmeticSelf : public PrimitiveC {
  public:
+  ArithmeticSelf() = default;
+  ~ArithmeticSelf() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(ArithmeticSelf, PrimitiveC);
-  ArithmeticSelf() = default;
   explicit ArithmeticSelf(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
 #else
   //  explicit ArithmeticSelf(schema::Primitive *primitive) : PrimitiveC(primitive) {}
-  ArithmeticSelf() = default;
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override {
     return RET_ERROR;
   }

mindspore/lite/src/ops/assign.h

@@ -26,13 +26,13 @@ namespace mindspore {
 namespace lite {
 class Assign : public PrimitiveC {
  public:
+  Assign() = default;
+  ~Assign() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(Assign, PrimitiveC);
-  Assign() = default;
   explicit Assign(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
   int UnPackAttr(const Primitive &prim, const std::vector<AnfNodePtr> &inputs) override;
 #else
-  Assign() = default;
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
   int InferShape(std::vector<lite::Tensor *> inputs_, std::vector<lite::Tensor *> outputs_) override;

mindspore/lite/src/ops/assign_add.h

@@ -24,14 +24,13 @@ namespace mindspore {
 namespace lite {
 class AssignAdd : public PrimitiveC {
  public:
+  AssignAdd() = default;
+  ~AssignAdd() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(AssignAdd, PrimitiveC);
-  AssignAdd() = default;
   explicit AssignAdd(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
   int UnPackAttr(const Primitive &prim, const std::vector<AnfNodePtr> &inputs) override;
 #else
-  AssignAdd() = default;
-
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
   int InferShape(std::vector<lite::Tensor *> inputs_, std::vector<lite::Tensor *> outputs_) override;

mindspore/lite/src/ops/audio_spectrogram.h

@@ -26,16 +26,15 @@ namespace mindspore {
 namespace lite {
 class AudioSpectrogram : public PrimitiveC {
  public:
+  AudioSpectrogram() = default;
+  ~AudioSpectrogram() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(AudioSpectrogram, PrimitiveC);
-  AudioSpectrogram() = default;
   explicit AudioSpectrogram(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
   void SetWindowSize(int window_size) { this->primitive_->value.AsAudioSpectrogram()->windowSize = window_size; }
   void SetStride(int stride) { this->primitive_->value.AsAudioSpectrogram()->stride = stride; }
   void SetMagSquare(bool mag_square) { this->primitive_->value.AsAudioSpectrogram()->magSquare = mag_square; }
 #else
-  AudioSpectrogram() = default;
-
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
   int GetWindowSize() const;

mindspore/lite/src/ops/batch_norm.h

@@ -26,15 +26,14 @@ namespace mindspore {
 namespace lite {
 class BatchNorm : public PrimitiveC {
  public:
+  BatchNorm() = default;
+  ~BatchNorm() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(BatchNorm, PrimitiveC);
-  BatchNorm() = default;
   explicit BatchNorm(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
   int UnPackAttr(const Primitive &prim, const std::vector<AnfNodePtr> &inputs) override;
   void SetEpsilon(float epsilon);
 #else
-  BatchNorm() = default;
-
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
   float GetEpsilon() const;

mindspore/lite/src/ops/batch_to_space.h

@@ -27,15 +27,14 @@ namespace mindspore {
 namespace lite {
 class BatchToSpace : public PrimitiveC {
  public:
+  BatchToSpace() = default;
+  ~BatchToSpace() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(BatchToSpace, PrimitiveC);
-  BatchToSpace() = default;
   explicit BatchToSpace(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
   void SetBlockShape(const std::vector<int> &block_shape);
   void SetCrops(const std::vector<int> &crops);
 #else
-  BatchToSpace() = default;
-
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
   int InferShape(std::vector<lite::Tensor *> inputs_, std::vector<lite::Tensor *> outputs_) override;

mindspore/lite/src/ops/bias_add.h

@@ -27,15 +27,14 @@ namespace mindspore {
 namespace lite {
 class BiasAdd : public PrimitiveC {
  public:
+  BiasAdd() = default;
+  ~BiasAdd() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(BiasAdd, PrimitiveC);
-  BiasAdd() = default;
   explicit BiasAdd(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
   int UnPackAttr(const Primitive &prim, const std::vector<AnfNodePtr> &inputs) override;
   void SetAxis(const std::vector<int> &axis);
 #else
-  BiasAdd() = default;
-
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
   std::vector<int> GetAxis() const;

mindspore/lite/src/ops/bias_grad.h

@@ -27,15 +27,14 @@ namespace mindspore {
 namespace lite {
 class BiasGrad : public PrimitiveC {
  public:
+  BiasGrad() = default;
+  ~BiasGrad() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(BiasGrad, PrimitiveC);
-  BiasGrad() = default;
   explicit BiasGrad(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
   void SetAxis(const std::vector<int> &axis);
   int UnPackAttr(const Primitive &prim, const std::vector<AnfNodePtr> &inputs) override;
 #else
-  BiasGrad() = default;
-
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
   int InferShape(std::vector<lite::Tensor *> inputs, std::vector<lite::Tensor *> outputs) override;

mindspore/lite/src/ops/binary_cross_entropy.h

@@ -25,19 +25,17 @@ namespace mindspore {
 namespace lite {
 class BinaryCrossEntropy : public PrimitiveC {
  public:
+  BinaryCrossEntropy() = default;
+  ~BinaryCrossEntropy() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(BinaryCrossEntropy, PrimitiveC);
 
-  BinaryCrossEntropy() = default;
-
   explicit BinaryCrossEntropy(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
 
   int UnPackAttr(const Primitive &prim, const std::vector<AnfNodePtr> &inputs) override;
 
   int GetReduction() const;
 #else
-  BinaryCrossEntropy() = default;
-
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 
   int GetReduction() const;

mindspore/lite/src/ops/binary_cross_entropy_grad.h

@@ -25,19 +25,17 @@ namespace mindspore {
 namespace lite {
 class BinaryCrossEntropyGrad : public PrimitiveC {
  public:
+  BinaryCrossEntropyGrad() = default;
+  ~BinaryCrossEntropyGrad() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(BinaryCrossEntropyGrad, PrimitiveC);
 
-  BinaryCrossEntropyGrad() = default;
-
   explicit BinaryCrossEntropyGrad(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
 
   int UnPackAttr(const Primitive &prim, const std::vector<AnfNodePtr> &inputs) override;
 
   int GetReduction() const;
 #else
-  BinaryCrossEntropyGrad() = default;
-
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 
   int GetReduction() const;

mindspore/lite/src/ops/bn_grad.h

@@ -26,15 +26,15 @@ namespace mindspore {
 namespace lite {
 class BNGrad : public PrimitiveC {
  public:
+  BNGrad() = default;
+  ~BNGrad() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(BNGrad, PrimitiveC);
-  BNGrad() = default;
   explicit BNGrad(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
   void SetEps(float eps);
   void SetMomentum(float momentum);
   int UnPackAttr(const Primitive &prim, const std::vector<AnfNodePtr> &inputs) override;
 #else
-  BNGrad() = default;
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
   int InferShape(std::vector<lite::Tensor *> inputs_, std::vector<lite::Tensor *> outputs_) override;

mindspore/lite/src/ops/broadcast_to.h

@@ -27,15 +27,14 @@ namespace mindspore {
 namespace lite {
 class BroadcastTo : public PrimitiveC {
  public:
+  BroadcastTo() = default;
+  ~BroadcastTo() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(BroadcastTo, PrimitiveC);
-  BroadcastTo() = default;
   explicit BroadcastTo(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
   void SetDstShape(const std::vector<int> &dst_shape);
 
 #else
-  BroadcastTo() = default;
-
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
   int InferShape(std::vector<lite::Tensor *> inputs_, std::vector<lite::Tensor *> outputs_) override;

mindspore/lite/src/ops/cast.h

@@ -26,16 +26,15 @@ namespace mindspore {
 namespace lite {
 class Cast : public PrimitiveC {
  public:
+  Cast() = default;
+  ~Cast() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(Cast, PrimitiveC);
-  Cast() = default;
   explicit Cast(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
   void SetSrcT(int src_t);
   void SetDstT(int dst_t);
   int UnPackAttr(const Primitive &prim, const std::vector<AnfNodePtr> &inputs);
 #else
-  Cast() = default;
-
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
   int InferShape(std::vector<lite::Tensor *> inputs_, std::vector<lite::Tensor *> outputs_) override;

mindspore/lite/src/ops/ceil.h

@@ -26,13 +26,12 @@ namespace mindspore {
 namespace lite {
 class Ceil : public ArithmeticSelf {
  public:
+  Ceil() = default;
+  ~Ceil() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(Ceil, ArithmeticSelf);
-  Ceil() = default;
   explicit Ceil(schema::PrimitiveT *primitive) : ArithmeticSelf(primitive) {}
 #else
-  Ceil() = default;
-
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override {
     MS_ASSERT(nullptr != primitive);
     MS_ASSERT(nullptr != fbb);

mindspore/lite/src/ops/clip.h

@@ -26,15 +26,14 @@ namespace mindspore {
 namespace lite {
 class Clip : public PrimitiveC {
  public:
+  Clip() = default;
+  ~Clip() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(Clip, PrimitiveC);
-  Clip() = default;
   explicit Clip(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
   void SetMax(float max);
   void SetMin(float min);
 #else
-  Clip() = default;
-
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
   float GetMax() const;

mindspore/lite/src/ops/concat.h

@@ -26,16 +26,15 @@ namespace mindspore {
 namespace lite {
 class Concat : public PrimitiveC {
  public:
+  Concat() = default;
+  ~Concat() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(Concat, PrimitiveC);
-  Concat() = default;
   explicit Concat(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
   int UnPackAttr(const Primitive &prim, const std::vector<AnfNodePtr> &inputs) override;
   void SetAxis(int axis);
   void SetN(int n);
 #else
-  Concat() = default;
-
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
   int InferShape(std::vector<lite::Tensor *> inputs_, std::vector<lite::Tensor *> outputs_) override;

mindspore/lite/src/ops/constant_of_shape.h

@@ -26,13 +26,12 @@ namespace mindspore {
 namespace lite {
 class ConstantOfShape : public PrimitiveC {
  public:
+  ConstantOfShape() = default;
+  ~ConstantOfShape() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(ConstantOfShape, PrimitiveC);
-  ConstantOfShape() = default;
   explicit ConstantOfShape(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
 #else
-  ConstantOfShape() = default;
-
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
   int InferShape(std::vector<lite::Tensor *> inputs_, std::vector<lite::Tensor *> outputs_) override;

mindspore/lite/src/ops/control_depend.h

@@ -24,13 +24,13 @@ namespace mindspore {
 namespace lite {
 class ControlDepend : public PrimitiveC {
  public:
+  ControlDepend() = default;
+  ~ControlDepend() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(ControlDepend, PrimitiveC);
-  ControlDepend() = default;
   explicit ControlDepend(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
   int UnPackAttr(const Primitive &prim, const std::vector<AnfNodePtr> &inputs) override;
 #else
-  ControlDepend() = default;
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
 };

mindspore/lite/src/ops/conv2d.h

@@ -26,11 +26,11 @@
 namespace mindspore {
 namespace lite {
 class Conv2D : public PrimitiveC {
-#ifdef PRIMITIVE_WRITEABLE
-  MS_DECLARE_PARENT(Conv2D, PrimitiveC);
-
  public:
   Conv2D() = default;
+  ~Conv2D() = default;
+#ifdef PRIMITIVE_WRITEABLE
+  MS_DECLARE_PARENT(Conv2D, PrimitiveC);
   explicit Conv2D(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
 
   int UnPackAttr(const Primitive &prim, const std::vector<AnfNodePtr> &inputs) override;
@@ -57,10 +57,6 @@ class Conv2D : public PrimitiveC {
                                  const std::vector<AnfNodePtr> &inputs);
   void PopulaterConv2DSingleGroup(const Primitive &prim, schema::PrimitiveT *primitive, const int &group);
 #else
-
- public:
-  Conv2D() = default;
-
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
 

mindspore/lite/src/ops/conv2d_grad_filter.h

@@ -28,9 +28,10 @@ namespace mindspore {
 namespace lite {
 class Conv2DGradFilter : public PrimitiveC {
  public:
+  Conv2DGradFilter() = default;
+  ~Conv2DGradFilter() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(Conv2DGradFilter, PrimitiveC);
-  Conv2DGradFilter() = default;
   explicit Conv2DGradFilter(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
   void SetFormat(int format);
   void SetGroup(int group);
@@ -51,8 +52,6 @@ class Conv2DGradFilter : public PrimitiveC {
   void SetActivationType(int activation_type);
   int UnPackAttr(const Primitive &prim, const std::vector<AnfNodePtr> &inputs) override;
 #else
-  Conv2DGradFilter() = default;
-
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
   int InferShape(std::vector<lite::Tensor *> inputs_, std::vector<lite::Tensor *> outputs_) override;

mindspore/lite/src/ops/conv2d_grad_input.h

@@ -28,9 +28,10 @@ namespace mindspore {
 namespace lite {
 class Conv2DGradInput : public PrimitiveC {
  public:
+  Conv2DGradInput() = default;
+  ~Conv2DGradInput() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(Conv2DGradInput, PrimitiveC);
-  Conv2DGradInput() = default;
   explicit Conv2DGradInput(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
   void SetFormat(int format);
   void SetGroup(int group);
@@ -51,8 +52,6 @@ class Conv2DGradInput : public PrimitiveC {
   void SetActivationType(int activation_type);
   int UnPackAttr(const Primitive &prim, const std::vector<AnfNodePtr> &inputs) override;
 #else
-  Conv2DGradInput() = default;
-
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
   int InferShape(std::vector<lite::Tensor *> inputs_, std::vector<lite::Tensor *> outputs_) override;

mindspore/lite/src/ops/cos.h

@@ -26,12 +26,11 @@ namespace mindspore {
 namespace lite {
 class Cos : public ArithmeticSelf {
  public:
-#ifdef PRIMITIVE_WRITEABLE
   Cos() = default;
+  ~Cos() = default;
+#ifdef PRIMITIVE_WRITEABLE
   explicit Cos(schema::PrimitiveT *primitive) : ArithmeticSelf(primitive) {}
 #else
-  Cos() = default;
-
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
 };

mindspore/lite/src/ops/crop.h

@@ -27,15 +27,14 @@ namespace mindspore {
 namespace lite {
 class Crop : public PrimitiveC {
  public:
+  Crop() = default;
+  ~Crop() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(Crop, PrimitiveC);
-  Crop() = default;
   explicit Crop(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
   void SetAxis(int64_t axis);
   void SetOffsets(const std::vector<int64_t> &offsets);
 #else
-  Crop() = default;
-
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
   int InferShape(std::vector<lite::Tensor *> inputs_, std::vector<lite::Tensor *> outputs_) override;

mindspore/lite/src/ops/custom_extract_features.h

@@ -23,13 +23,13 @@ namespace mindspore {
 namespace lite {
 class CustomExtractFeatures : public PrimitiveC {
  public:
+  CustomExtractFeatures() = default;
+  ~CustomExtractFeatures() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(CustomExtractFeatures, PrimitiveC);
-  CustomExtractFeatures() = default;
   explicit CustomExtractFeatures(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
   int UnPackAttr(const Primitive &prim, const std::vector<AnfNodePtr> &inputs) override;
 #else
-  CustomExtractFeatures() = default;
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
   int InferShape(std::vector<Tensor *> inputs_, std::vector<Tensor *> outputs_) override;

mindspore/lite/src/ops/custom_normalize.h

@@ -23,13 +23,13 @@ namespace mindspore {
 namespace lite {
 class CustomNormalize : public PrimitiveC {
  public:
+  CustomNormalize() = default;
+  ~CustomNormalize() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(CustomNormalize, PrimitiveC);
-  CustomNormalize() = default;
   explicit CustomNormalize(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
   int UnPackAttr(const Primitive &prim, const std::vector<AnfNodePtr> &inputs) override;
 #else
-  CustomNormalize() = default;
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
   int InferShape(std::vector<Tensor *> inputs_, std::vector<Tensor *> outputs_) override;

mindspore/lite/src/ops/custom_predict.h

@@ -23,9 +23,10 @@ namespace mindspore {
 namespace lite {
 class CustomPredict : public PrimitiveC {
  public:
+  CustomPredict() = default;
+  ~CustomPredict() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(CustomPredict, PrimitiveC);
-  CustomPredict() = default;
   explicit CustomPredict(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
   int GetOutputNum() const;
   float GetWeightThreshold() const;
@@ -33,7 +34,6 @@ class CustomPredict : public PrimitiveC {
   void SetWeightThreshold(float weight_threshold);
   int UnPackAttr(const Primitive &prim, const std::vector<AnfNodePtr> &inputs) override;
 #else
-  CustomPredict() = default;
   int GetOutputNum() const;
   float GetWeightThreshold() const;
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;

mindspore/lite/src/ops/deconv2d.h

@@ -26,9 +26,10 @@ namespace mindspore {
 namespace lite {
 class DeConv2D : public PrimitiveC {
  public:
+  DeConv2D() = default;
+  ~DeConv2D() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(DeConv2D, PrimitiveC);
-  DeConv2D() = default;
   explicit DeConv2D(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
   void SetFormat(int format);
   void SetGroup(int group);
@@ -51,10 +52,7 @@ class DeConv2D : public PrimitiveC {
   void PopulaterConv2DMultiGroup(const Primitive &prim, schema::PrimitiveT *primitive, const int &group,
                                  const std::vector<AnfNodePtr> &inputs);
   int UnPackAttr(const Primitive &prim, const std::vector<AnfNodePtr> &inputs) override;
-
 #else
-  DeConv2D() = default;
-
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
   int InferShape(std::vector<lite::Tensor *> inputs_, std::vector<lite::Tensor *> outputs_) override;

mindspore/lite/src/ops/dedepthwise_conv2d.h

@@ -26,9 +26,10 @@ namespace mindspore {
 namespace lite {
 class DeDepthwiseConv2D : public PrimitiveC {
  public:
+  DeDepthwiseConv2D() = default;
+  ~DeDepthwiseConv2D() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(DeDepthwiseConv2D, PrimitiveC);
-  DeDepthwiseConv2D() = default;
   explicit DeDepthwiseConv2D(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
   void SetFormat(int format);
   void SetChannelIn(int channel_in);
@@ -47,8 +48,6 @@ class DeDepthwiseConv2D : public PrimitiveC {
   void SetHasBias(bool has_bias);
   void SetActivationType(int activation_type);
 #else
-  DeDepthwiseConv2D() = default;
-
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
   int InferShape(std::vector<lite::Tensor *> inputs_, std::vector<lite::Tensor *> outputs_) override;

mindspore/lite/src/ops/depend.h

@@ -24,13 +24,13 @@ namespace mindspore {
 namespace lite {
 class Depend : public PrimitiveC {
  public:
+  Depend() = default;
+  ~Depend() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(Depend, PrimitiveC);
-  Depend() = default;
   explicit Depend(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
   int UnPackAttr(const Primitive &prim, const std::vector<AnfNodePtr> &inputs) override;
 #else
-  Depend() = default;
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
 };

mindspore/lite/src/ops/depth_to_space.h

@@ -26,15 +26,14 @@ namespace mindspore {
 namespace lite {
 class DepthToSpace : public PrimitiveC {
  public:
+  DepthToSpace() = default;
+  ~DepthToSpace() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(DepthToSpace, PrimitiveC);
-  DepthToSpace() = default;
   explicit DepthToSpace(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
   void SetBlockSize(int block_size);
   void SetFormat(int format);
 #else
-  DepthToSpace() = default;
-
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
   int InferShape(std::vector<lite::Tensor *> inputs_, std::vector<lite::Tensor *> outputs_) override;

mindspore/lite/src/ops/depthwise_conv2d.h

@@ -25,11 +25,11 @@
 namespace mindspore {
 namespace lite {
 class DepthwiseConv2D : public PrimitiveC {
-#ifdef PRIMITIVE_WRITEABLE
-  MS_DECLARE_PARENT(DepthwiseConv2D, PrimitiveC);
-
  public:
   DepthwiseConv2D() = default;
+  ~DepthwiseConv2D() = default;
+#ifdef PRIMITIVE_WRITEABLE
+  MS_DECLARE_PARENT(DepthwiseConv2D, PrimitiveC);
   explicit DepthwiseConv2D(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
 
   int UnPackAttr(const Primitive &prim, const std::vector<AnfNodePtr> &inputs) override;
@@ -49,16 +49,10 @@ class DepthwiseConv2D : public PrimitiveC {
   void SetDilateH(int dilate_h);
   void SetHasBias(bool has_bias);
   void SetActivationType(int activation_type);
-
 #else
-
- public:
-  DepthwiseConv2D() = default;
-
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
 
- public:
   int InferShape(std::vector<lite::Tensor *> inputs_, std::vector<lite::Tensor *> outputs_) override;
   int GetFormat() const;
   int GetChannelIn() const;

mindspore/lite/src/ops/dequant.h

@@ -24,13 +24,12 @@ namespace mindspore {
 namespace lite {
 class Dequant : public PrimitiveC {
  public:
+  Dequant() = default;
+  ~Dequant() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(Dequant, PrimitiveC);
-  Dequant() = default;
   explicit Dequant(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
   int UnPackAttr(const Primitive &prim, const std::vector<AnfNodePtr> &inputs) override;
-#else
-  Dequant() = default;
 #endif
 };
 }  // namespace lite

mindspore/lite/src/ops/detection_post_process.h

@@ -26,9 +26,10 @@ namespace mindspore {
 namespace lite {
 class DetectionPostProcess : public PrimitiveC {
  public:
+  DetectionPostProcess() = default;
+  ~DetectionPostProcess() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(DetectionPostProcess, PrimitiveC);
-  DetectionPostProcess() = default;
   explicit DetectionPostProcess(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
   void SetFormat(int format);
   void SetInputSize(int input_size);
@@ -45,8 +46,6 @@ class DetectionPostProcess : public PrimitiveC {
   void SetUseRegularNms(bool use_regular_nms);
   void SetOutQuantized(bool out_quantized);
 #else
-  DetectionPostProcess() = default;
-
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
   int InferShape(std::vector<lite::Tensor *> inputs_, std::vector<lite::Tensor *> outputs_) override;

mindspore/lite/src/ops/div.h

@@ -26,15 +26,14 @@ namespace mindspore {
 namespace lite {
 class Div : public Arithmetic {
  public:
+  Div() = default;
+  ~Div() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(Div, Arithmetic);
-  Div() = default;
   explicit Div(schema::PrimitiveT *primitive) : Arithmetic(primitive) {}
   void SetActivationType(int activation_type);
 
 #else
-  Div() = default;
-
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
   int GetActivationType() const;

mindspore/lite/src/ops/dropout.h

@@ -26,15 +26,14 @@ namespace mindspore {
 namespace lite {
 class Dropout : public PrimitiveC {
  public:
+  Dropout() = default;
+  ~Dropout() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(Dropout, PrimitiveC);
-  Dropout() = default;
   explicit Dropout(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
   void SetRatio(float ratio);
 
 #else
-  Dropout() = default;
-
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
   float GetRatio() const;

mindspore/lite/src/ops/eltwise.h

@@ -27,14 +27,14 @@ namespace mindspore {
 namespace lite {
 class Eltwise : public Arithmetic {
  public:
+  Eltwise() = default;
+  ~Eltwise() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(Eltwise, Arithmetic);
-  Eltwise() = default;
   explicit Eltwise(schema::PrimitiveT *primitive) : Arithmetic(primitive) {}
   void SetMode(int mode);
 
 #else
-  Eltwise() = default;
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
   int GetMode() const;

mindspore/lite/src/ops/elu.h

@@ -26,15 +26,14 @@ namespace mindspore {
 namespace lite {
 class Elu : public PrimitiveC {
  public:
+  Elu() = default;
+  ~Elu() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(Elu, PrimitiveC);
-  Elu() = default;
   explicit Elu(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
   void SetAlpha(float alpha);
   int UnPackAttr(const Primitive &prim, const std::vector<AnfNodePtr> &inputs) override;
 #else
-  Elu() = default;
-
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
   float GetAlpha() const;

mindspore/lite/src/ops/embedding_lookup.h

@@ -26,15 +26,14 @@ namespace mindspore {
 namespace lite {
 class EmbeddingLookup : public PrimitiveC {
  public:
+  EmbeddingLookup() = default;
+  ~EmbeddingLookup() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(EmbeddingLookup, PrimitiveC);
-  EmbeddingLookup() = default;
   explicit EmbeddingLookup(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
   void SetMaxNorm(float max_norm);
 
 #else
-  EmbeddingLookup() = default;
-
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
   int InferShape(std::vector<lite::Tensor *> inputs_, std::vector<lite::Tensor *> outputs_) override;

mindspore/lite/src/ops/embedding_lookup_sparse.h

@@ -27,16 +27,15 @@ namespace mindspore {
 namespace lite {
 class EmbeddingLookupSparse : public PrimitiveC {
  public:
+  EmbeddingLookupSparse() = default;
+  ~EmbeddingLookupSparse() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(EmbeddingLookupSparse, PrimitiveC);
-  EmbeddingLookupSparse() = default;
   explicit EmbeddingLookupSparse(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
   void SetSpIds(const std::vector<int> &sp_ids);
   void SetSpWeights(const std::vector<float> &sp_weights);
   void SetMaxNortm(float max_nortm);
 #else
-  EmbeddingLookupSparse() = default;
-
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
   std::vector<int> GetSpIds() const;

mindspore/lite/src/ops/equal.h

@@ -26,13 +26,12 @@ namespace mindspore {
 namespace lite {
 class Equal : public Arithmetic {
  public:
+  Equal() = default;
+  ~Equal() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(Equal, PrimitiveC);
-  Equal() = default;
   explicit Equal(schema::PrimitiveT *primitive) : Arithmetic(primitive) {}
 #else
-  Equal() = default;
-
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
   int InferShape(std::vector<lite::Tensor *> inputs_, std::vector<lite::Tensor *> outputs_) override;

mindspore/lite/src/ops/exp.h

@@ -26,17 +26,16 @@ namespace mindspore {
 namespace lite {
 class Exp : public PrimitiveC {
  public:
+  Exp() = default;
+  ~Exp() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(Exp, PrimitiveC);
-  Exp() = default;
   explicit Exp(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
   void SetBase(float base);
   void SetShift(float shift);
   void SetScale(float scale);
   int UnPackAttr(const Primitive &prim, const std::vector<AnfNodePtr> &inputs) override;
 #else
-  Exp() = default;
-
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
   float GetBase() const;

mindspore/lite/src/ops/expand_dims.h

@@ -26,16 +26,15 @@ namespace mindspore {
 namespace lite {
 class ExpandDims : public PrimitiveC {
  public:
+  ExpandDims() = default;
+  ~ExpandDims() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(ExpandDims, PrimitiveC);
-  ExpandDims() = default;
   explicit ExpandDims(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
   void SetDim(int dim);
   int UnPackAttr(const Primitive &prim, const std::vector<AnfNodePtr> &inputs) override;
 
 #else
-  ExpandDims() = default;
-
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
   int InferShape(std::vector<lite::Tensor *> inputs_, std::vector<lite::Tensor *> outputs_) override;

mindspore/lite/src/ops/fake_quant_with_min_max_vars.h

@@ -26,15 +26,14 @@ namespace mindspore {
 namespace lite {
 class FakeQuantWithMinMaxVars : public PrimitiveC {
  public:
+  FakeQuantWithMinMaxVars() = default;
+  ~FakeQuantWithMinMaxVars() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(FakeQuantWithMinMaxVars, PrimitiveC);
-  FakeQuantWithMinMaxVars() = default;
   explicit FakeQuantWithMinMaxVars(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
   void SetNarrowRange(bool narrow_range);
   void SetNumBits(int num_bits);
 #else
-  FakeQuantWithMinMaxVars() = default;
-
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
   bool GetNarrowRange() const;

mindspore/lite/src/ops/fft_imag.h

@@ -26,13 +26,12 @@ namespace mindspore {
 namespace lite {
 class FftImag : public PrimitiveC {
  public:
+  FftImag() = default;
+  ~FftImag() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(FftImag, PrimitiveC);
-  FftImag() = default;
   explicit FftImag(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
 #else
-  FftImag() = default;
-
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
   int InferShape(std::vector<lite::Tensor *> inputs_, std::vector<lite::Tensor *> outputs_) override;

mindspore/lite/src/ops/fft_real.h

@@ -26,13 +26,12 @@ namespace mindspore {
 namespace lite {
 class FftReal : public PrimitiveC {
  public:
+  FftReal() = default;
+  ~FftReal() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(FftReal, PrimitiveC);
-  FftReal() = default;
   explicit FftReal(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
 #else
-  FftReal() = default;
-
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
   int InferShape(std::vector<lite::Tensor *> inputs_, std::vector<lite::Tensor *> outputs_) override;

mindspore/lite/src/ops/fill.h

@@ -27,15 +27,14 @@ namespace mindspore {
 namespace lite {
 class Fill : public PrimitiveC {
  public:
+  Fill() = default;
+  ~Fill() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(Fill, PrimitiveC);
-  Fill() = default;
   explicit Fill(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
   void SetDims(const std::vector<int> &dims);
 
 #else
-  Fill() = default;
-
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
   int InferShape(std::vector<lite::Tensor *> inputs_, std::vector<lite::Tensor *> outputs_) override;

mindspore/lite/src/ops/flatten.h

@@ -26,14 +26,13 @@ namespace mindspore {
 namespace lite {
 class Flatten : public PrimitiveC {
  public:
+  Flatten() = default;
+  ~Flatten() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(Flatten, PrimitiveC);
-  Flatten() = default;
   explicit Flatten(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
   int UnPackAttr(const Primitive &prim, const std::vector<AnfNodePtr> &inputs) override;
 #else
-  Flatten() = default;
-
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
   int InferShape(std::vector<lite::Tensor *> inputs_, std::vector<lite::Tensor *> outputs_) override;

mindspore/lite/src/ops/flatten_grad.h

@@ -26,14 +26,13 @@ namespace mindspore {
 namespace lite {
 class FlattenGrad : public PrimitiveC {
  public:
+  FlattenGrad() = default;
+  ~FlattenGrad() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(FlattenGrad, PrimitiveC);
-  FlattenGrad() = default;
   explicit FlattenGrad(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
   int UnPackAttr(const Primitive &prim, const std::vector<AnfNodePtr> &inputs) override;
 #else
-  FlattenGrad() = default;
-
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
   int InferShape(std::vector<lite::Tensor *> inputs_, std::vector<lite::Tensor *> outputs_) override;

mindspore/lite/src/ops/floor.h

@@ -26,13 +26,12 @@ namespace mindspore {
 namespace lite {
 class Floor : public ArithmeticSelf {
  public:
+  Floor() = default;
+  ~Floor() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(Floor, ArithmeticSelf);
-  Floor() = default;
   explicit Floor(schema::PrimitiveT *primitive) : ArithmeticSelf(primitive) {}
 #else
-  Floor() = default;
-
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
 };

mindspore/lite/src/ops/floor_div.h

@@ -26,13 +26,12 @@ namespace mindspore {
 namespace lite {
 class FloorDiv : public Arithmetic {
  public:
+  FloorDiv() = default;
+  ~FloorDiv() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(FloorDiv, Arithmetic);
-  FloorDiv() = default;
   explicit FloorDiv(schema::PrimitiveT *primitive) : Arithmetic(primitive) {}
 #else
-  FloorDiv() = default;
-
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
 };

mindspore/lite/src/ops/floor_mod.h

@@ -26,13 +26,12 @@ namespace mindspore {
 namespace lite {
 class FloorMod : public Arithmetic {
  public:
+  FloorMod() = default;
+  ~FloorMod() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(FloorMod, Arithmetic);
-  FloorMod() = default;
   explicit FloorMod(schema::PrimitiveT *primitive) : Arithmetic(primitive) {}
 #else
-  FloorMod() = default;
-
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
 };

mindspore/lite/src/ops/full_connection.h

@@ -26,17 +26,16 @@ namespace mindspore {
 namespace lite {
 class FullConnection : public PrimitiveC {
  public:
+  FullConnection() = default;
+  ~FullConnection() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(FullConnection, PrimitiveC);
-  FullConnection() = default;
   explicit FullConnection(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
   void SetHasBias(bool has_bias);
   void SetAxis(int axis);
   void SetUseAxis(bool use_axis);
   void SetActivationType(int activationType);
 #else
-  FullConnection() = default;
-
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
   int InferShape(std::vector<lite::Tensor *> inputs_, std::vector<lite::Tensor *> outputs_) override;

mindspore/lite/src/ops/fused_batchnorm.h

@@ -26,17 +26,16 @@ namespace mindspore {
 namespace lite {
 class FusedBatchNorm : public PrimitiveC {
  public:
+  FusedBatchNorm() = default;
+  ~FusedBatchNorm() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(FusedBatchNorm, PrimitiveC);
-  FusedBatchNorm() = default;
   explicit FusedBatchNorm(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
   void SetEpsilon(float epsilon);
   void SetMomentum(float momentum);
   void SetSpatial(int spatial);
   int UnPackAttr(const Primitive &prim, const std::vector<AnfNodePtr> &inputs) override;
 #else
-  FusedBatchNorm() = default;
-
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
   int InferShape(std::vector<lite::Tensor *> inputs_, std::vector<lite::Tensor *> outputs_) override;

mindspore/lite/src/ops/gather.h

@@ -27,16 +27,15 @@ namespace mindspore {
 namespace lite {
 class Gather : public PrimitiveC {
  public:
+  Gather() = default;
+  ~Gather() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(Gather, PrimitiveC);
-  Gather() = default;
   explicit Gather(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
   void SetAxis(int axis);
   void SetBatchDims(int batch_dims);
   int UnPackAttr(const Primitive &prim, const std::vector<AnfNodePtr> &inputs) override;
 #else
-  Gather() = default;
-
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
   int InferShape(std::vector<lite::Tensor *> inputs_, std::vector<lite::Tensor *> outputs_) override;

mindspore/lite/src/ops/gather_nd.h

@@ -27,15 +27,14 @@ namespace mindspore {
 namespace lite {
 class GatherNd : public PrimitiveC {
  public:
+  GatherNd() = default;
+  ~GatherNd() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(GatherNd, PrimitiveC);
-  GatherNd() = default;
   explicit GatherNd(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
   void SetBatchDims(int batch_dims);
 
 #else
-  GatherNd() = default;
-
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
   int InferShape(std::vector<lite::Tensor *> inputs_, std::vector<lite::Tensor *> outputs_) override;

mindspore/lite/src/ops/greater.h

@@ -26,13 +26,12 @@ namespace mindspore {
 namespace lite {
 class Greater : public Arithmetic {
  public:
+  Greater() = default;
+  ~Greater() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(Greater, Arithmetic);
-  Greater() = default;
   explicit Greater(schema::PrimitiveT *primitive) : Arithmetic(primitive) {}
 #else
-  Greater() = default;
-
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
   int InferShape(std::vector<lite::Tensor *> inputs_, std::vector<lite::Tensor *> outputs_) override;

mindspore/lite/src/ops/greater_equal.h

@@ -27,13 +27,12 @@ namespace mindspore {
 namespace lite {
 class GreaterEqual : public Arithmetic {
  public:
+  GreaterEqual() = default;
+  ~GreaterEqual() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(GreaterEqual, Arithmetic);
-  GreaterEqual() = default;
   explicit GreaterEqual(schema::PrimitiveT *primitive) : Arithmetic(primitive) {}
 #else
-  GreaterEqual() = default;
-
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
   int InferShape(std::vector<lite::Tensor *> inputs_, std::vector<lite::Tensor *> outputs_) override;

mindspore/lite/src/ops/group_conv2d_grad_input.h

@@ -28,9 +28,10 @@ namespace mindspore {
 namespace lite {
 class GroupConv2DGradInput : public PrimitiveC {
  public:
+  GroupConv2DGradInput() = default;
+  ~GroupConv2DGradInput() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(GroupConv2DGradInput, PrimitiveC);
-  GroupConv2DGradInput() = default;
   explicit GroupConv2DGradInput(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
   void SetFormat(int format);
   void SetGroup(int group);
@@ -50,8 +51,6 @@ class GroupConv2DGradInput : public PrimitiveC {
   void SetHasBias(bool has_bias);
   void SetActivationType(int activation_type);
 #else
-  GroupConv2DGradInput() = default;
-
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
   int InferShape(std::vector<lite::Tensor *> inputs_, std::vector<lite::Tensor *> outputs_) override;

mindspore/lite/src/ops/hashtable_lookup.h

@@ -23,13 +23,13 @@ namespace mindspore {
 namespace lite {
 class HashtableLookup : public PrimitiveC {
  public:
+  HashtableLookup() = default;
+  ~HashtableLookup() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(HashtableLookup, PrimitiveC);
-  HashtableLookup() = default;
   explicit HashtableLookup(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
   int UnPackAttr(const Primitive &prim, const std::vector<AnfNodePtr> &inputs) override;
 #else
-  HashtableLookup() = default;
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
   int InferShape(std::vector<Tensor *> inputs_, std::vector<Tensor *> outputs_) override;

mindspore/lite/src/ops/identity.h

@@ -25,6 +25,7 @@ class Identity : public PrimitiveC {
  public:
   MS_DECLARE_PARENT(Identity, PrimitiveC);
   Identity() = default;
+  ~Identity() = default;
   explicit Identity(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
 };
 }  // namespace lite

mindspore/lite/src/ops/instance_norm.h

@@ -26,15 +26,14 @@ namespace mindspore {
 namespace lite {
 class InstanceNorm : public PrimitiveC {
  public:
+  InstanceNorm() = default;
+  ~InstanceNorm() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(InstanceNorm, PrimitiveC);
-  InstanceNorm() = default;
   explicit InstanceNorm(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
   int UnPackAttr(const Primitive &prim, const std::vector<AnfNodePtr> &inputs) override;
   void SetEpsilon(float epsilon);
 #else
-  InstanceNorm() = default;
-
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
   float GetEpsilon() const;

mindspore/lite/src/ops/l2_norm.h

@@ -28,16 +28,15 @@ namespace mindspore {
 namespace lite {
 class L2Norm : public PrimitiveC {
  public:
+  L2Norm() = default;
+  ~L2Norm() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(L2Norm, PrimitiveC);
-  L2Norm() = default;
   explicit L2Norm(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
   void SetAxis(const std::vector<int> &axis);
   void SetEpsilon(float epsilon);
   void SetActivationType(int activationType);
 #else
-  L2Norm() = default;
-
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
   std::vector<int> GetAxis() const;

mindspore/lite/src/ops/layer_norm.h

@@ -27,16 +27,15 @@ namespace mindspore {
 namespace lite {
 class LayerNorm : public PrimitiveC {
  public:
+  LayerNorm() = default;
+  ~LayerNorm() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(LayerNorm, PrimitiveC);
-  LayerNorm() = default;
   explicit LayerNorm(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
   void SetNormalizedShape(const std::vector<int> &normalizedShape);
   void SetEpsilon(float epsilon);
   void SetElementwiseAffine(bool elementwiseAffine);
 #else
-  LayerNorm() = default;
-
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
   int InferShape(std::vector<lite::Tensor *> inputs_, std::vector<lite::Tensor *> outputs_) override;

mindspore/lite/src/ops/leaky_relu.h

@@ -27,15 +27,14 @@ namespace mindspore {
 namespace lite {
 class LeakyReLU : public PrimitiveC {
  public:
+  LeakyReLU() = default;
+  ~LeakyReLU() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(LeakyReLU, PrimitiveC);
-  LeakyReLU() = default;
   explicit LeakyReLU(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
   void SetNegativeSlope(float negative_slope);
 
 #else
-  LeakyReLU() = default;
-
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
   float GetNegativeSlope() const;

mindspore/lite/src/ops/less.h

@@ -27,13 +27,12 @@ namespace mindspore {
 namespace lite {
 class Less : public Arithmetic {
  public:
+  Less() = default;
+  ~Less() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(Less, Arithmetic);
-  Less() = default;
   explicit Less(schema::PrimitiveT *primitive) : Arithmetic(primitive) {}
 #else
-  Less() = default;
-
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
   int InferShape(std::vector<lite::Tensor *> inputs_, std::vector<lite::Tensor *> outputs_) override;

mindspore/lite/src/ops/less_equal.h

@@ -27,13 +27,12 @@ namespace mindspore {
 namespace lite {
 class LessEqual : public Arithmetic {
  public:
+  LessEqual() = default;
+  ~LessEqual() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(LessEqual, Arithmetic);
-  LessEqual() = default;
   explicit LessEqual(schema::PrimitiveT *primitive) : Arithmetic(primitive) {}
 #else
-  LessEqual() = default;
-
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
   int InferShape(std::vector<lite::Tensor *> inputs_, std::vector<lite::Tensor *> outputs_) override;

mindspore/lite/src/ops/local_response_normalization.h

@@ -27,17 +27,16 @@ namespace mindspore {
 namespace lite {
 class LocalResponseNormalization : public PrimitiveC {
  public:
+  LocalResponseNormalization() = default;
+  ~LocalResponseNormalization() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(LocalResponseNormalization, PrimitiveC);
-  LocalResponseNormalization() = default;
   explicit LocalResponseNormalization(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
   void SetDepthRadius(int depth_radius);
   void SetBias(float bias);
   void SetAlpha(float alpha);
   void SetBeta(float beta);
 #else
-  LocalResponseNormalization() = default;
-
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
   int GetDepthRadius() const;

mindspore/lite/src/ops/log.h

@@ -27,14 +27,13 @@ namespace mindspore {
 namespace lite {
 class Log : public ArithmeticSelf {
  public:
+  Log() = default;
+  ~Log() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(Log, ArithmeticSelf);
-  Log() = default;
   explicit Log(schema::PrimitiveT *primitive) : ArithmeticSelf(primitive) {}
   int UnPackAttr(const Primitive &prim, const std::vector<AnfNodePtr> &inputs) override;
 #else
-  Log() = default;
-
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
 };

mindspore/lite/src/ops/log_grad.h

@@ -27,13 +27,12 @@ namespace mindspore {
 namespace lite {
 class LogGrad : public PrimitiveC {
  public:
+  LogGrad() = default;
+  ~LogGrad() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(LogGrad, PrimitiveC);
-  LogGrad() = default;
   explicit LogGrad(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
 #else
-  LogGrad() = default;
-
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
 };

mindspore/lite/src/ops/logical_and.h

@@ -27,13 +27,12 @@ namespace mindspore {
 namespace lite {
 class LogicalAnd : public Arithmetic {
  public:
+  LogicalAnd() = default;
+  ~LogicalAnd() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(LogicalAnd, Arithmetic);
-  LogicalAnd() = default;
   explicit LogicalAnd(schema::PrimitiveT *primitive) : Arithmetic(primitive) {}
 #else
-  LogicalAnd() = default;
-
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
 };

mindspore/lite/src/ops/logical_not.h

@@ -27,13 +27,12 @@ namespace mindspore {
 namespace lite {
 class LogicalNot : public ArithmeticSelf {
  public:
+  LogicalNot() = default;
+  ~LogicalNot() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(LogicalNot, ArithmeticSelf);
-  LogicalNot() = default;
   explicit LogicalNot(schema::PrimitiveT *primitive) : ArithmeticSelf(primitive) {}
 #else
-  LogicalNot() = default;
-
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
 };

mindspore/lite/src/ops/logical_or.h

@@ -27,13 +27,12 @@ namespace mindspore {
 namespace lite {
 class LogicalOr : public Arithmetic {
  public:
+  LogicalOr() = default;
+  ~LogicalOr() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(LogicalOr, Arithmetic);
-  LogicalOr() = default;
   explicit LogicalOr(schema::PrimitiveT *primitive) : Arithmetic(primitive) {}
 #else
-  LogicalOr() = default;
-
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
 };

mindspore/lite/src/ops/lrn.h

@@ -27,17 +27,16 @@ namespace mindspore {
 namespace lite {
 class Lrn : public PrimitiveC {
  public:
+  Lrn() = default;
+  ~Lrn() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(Lrn, PrimitiveC);
-  Lrn() = default;
   explicit Lrn(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
   void SetAlpha(float alpha);
   void SetBeta(float beta);
   void SetBias(float bias);
   void SetSize(int size);
 #else
-  Lrn() = default;
-
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
   float GetAlpha() const;

mindspore/lite/src/ops/lsh_projection.h

@@ -23,13 +23,13 @@ namespace mindspore {
 namespace lite {
 class LshProjection : public PrimitiveC {
  public:
+  LshProjection() = default;
+  ~LshProjection() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(LshProjection, PrimitiveC);
-  LshProjection() = default;
   explicit LshProjection(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
   int UnPackAttr(const Primitive &prim, const std::vector<AnfNodePtr> &inputs) override;
 #else
-  LshProjection() = default;
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
   int InferShape(std::vector<Tensor *> inputs_, std::vector<Tensor *> outputs_) override;

mindspore/lite/src/ops/lstm.h

@@ -27,15 +27,14 @@ namespace mindspore {
 namespace lite {
 class Lstm : public PrimitiveC {
  public:
+  Lstm() = default;
+  ~Lstm() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(Lstm, PrimitiveC);
-  Lstm() = default;
   explicit Lstm(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
   void SetBidirection(bool bidirection);
 
 #else
-  Lstm() = default;
-
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
   int InferShape(std::vector<lite::Tensor *> inputs_, std::vector<lite::Tensor *> outputs_) override;

mindspore/lite/src/ops/make_tuple.h

@@ -23,14 +23,13 @@ namespace mindspore {
 namespace lite {
 class MakeTuple : public PrimitiveC {
  public:
+  MakeTuple() = default;
+  ~MakeTuple() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(MakeTuple, PrimitiveC);
-  MakeTuple() = default;
   explicit MakeTuple(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
   int UnPackAttr(const Primitive &prim, const std::vector<AnfNodePtr> &inputs) override;
 #else
-  MakeTuple() = default;
-
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
 };

mindspore/lite/src/ops/matmul.h

@@ -25,25 +25,18 @@
 namespace mindspore {
 namespace lite {
 class MatMul : public PrimitiveC {
-#ifdef PRIMITIVE_WRITEABLE
-  MS_DECLARE_PARENT(MatMul, PrimitiveC);
-
  public:
   MatMul() = default;
+  ~MatMul() = default;
+#ifdef PRIMITIVE_WRITEABLE
+  MS_DECLARE_PARENT(MatMul, PrimitiveC);
   explicit MatMul(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
   int UnPackAttr(const Primitive &prim, const std::vector<AnfNodePtr> &inputs) override;
   void SetTransposeA(bool transpose_a);
   void SetTransposeB(bool transpose_b);
-
 #else
-
- public:
-  MatMul() = default;
-
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
-
- public:
   int InferShape(std::vector<lite::Tensor *> inputs_, std::vector<lite::Tensor *> outputs_) override;
   bool GetTransposeA() const;
   bool GetTransposeB() const;

mindspore/lite/src/ops/matrix_diag.h

@@ -27,17 +27,16 @@ namespace mindspore {
 namespace lite {
 class MatrixDiag : public PrimitiveC {
  public:
+  MatrixDiag() = default;
+  ~MatrixDiag() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(MatrixDiag, PrimitiveC);
-  MatrixDiag() = default;
   explicit MatrixDiag(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
   void SetK(int k);
   void SetNumRows(int num_rows);
   void SetNumCols(int num_cols);
   void SetPaddingValue(float padding_value);
 #else
-  MatrixDiag() = default;
-
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
   int GetK() const;

mindspore/lite/src/ops/maximum.h

@@ -28,14 +28,13 @@ namespace mindspore {
 namespace lite {
 class Maximum : public Arithmetic {
  public:
+  Maximum() = default;
+  ~Maximum() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(Arithmetic, Arithmetic);
-  Maximum() = default;
   explicit Maximum(schema::PrimitiveT *primitive) : Arithmetic(primitive) {}
   int UnPackAttr(const Primitive &prim, const std::vector<AnfNodePtr> &inputs) override;
 #else
-  Maximum() = default;
-
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
 };

mindspore/lite/src/ops/mean.h

@@ -28,15 +28,14 @@ namespace mindspore {
 namespace lite {
 class Mean : public PrimitiveC {
  public:
+  Mean() = default;
+  ~Mean() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(Mean, PrimitiveC);
-  Mean() = default;
   explicit Mean(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
   void SetAxis(const std::vector<int> &axis);
   void SetKeepDims(bool keep_dims);
 #else
-  Mean() = default;
-
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
   int InferShape(std::vector<lite::Tensor *> inputs_, std::vector<lite::Tensor *> outputs_) override;

mindspore/lite/src/ops/mfcc.h

@@ -26,9 +26,10 @@ namespace mindspore {
 namespace lite {
 class Mfcc : public PrimitiveC {
  public:
+  Mfcc() = default;
+  ~Mfcc() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(Mfcc, PrimitiveC);
-  Mfcc() = default;
   explicit Mfcc(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
   void SetFreqUpperLimit(float freq_upper_limit) {
     this->primitive_->value.AsMfcc()->freqUpperLimit = freq_upper_limit;
@@ -41,8 +42,6 @@ class Mfcc : public PrimitiveC {
   }
   void SetDctCoeffNum(int dct_coeff_num) { this->primitive_->value.AsMfcc()->dctCoeffNum = dct_coeff_num; }
 #else
-  Mfcc() = default;
-
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
   float GetFreqUpperLimit() const;

mindspore/lite/src/ops/minimum.h

@@ -27,13 +27,12 @@ namespace mindspore {
 namespace lite {
 class Minimum : public Arithmetic {
  public:
+  Minimum() = default;
+  ~Minimum() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(Arithmetic, Arithmetic);
-  Minimum() = default;
   explicit Minimum(schema::PrimitiveT *primitive) : Arithmetic(primitive) {}
 #else
-  Minimum() = default;
-
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
 };

mindspore/lite/src/ops/mul.h

@@ -27,15 +27,14 @@ namespace mindspore {
 namespace lite {
 class Mul : public Arithmetic {
  public:
+  Mul() = default;
+  ~Mul() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(Mul, Arithmetic);
-  Mul() = default;
   explicit Mul(schema::PrimitiveT *primitive) : Arithmetic(primitive) {}
   void SetActivationType(int activation_type);
   int UnPackAttr(const Primitive &prim, const std::vector<AnfNodePtr> &inputs) override;
 #else
-  Mul() = default;
-
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
   int GetActivationType() const;

mindspore/lite/src/ops/nchw2nhwc.h

@@ -27,13 +27,12 @@ namespace mindspore {
 namespace lite {
 class Nchw2Nhwc : public PrimitiveC {
  public:
+  Nchw2Nhwc() = default;
+  ~Nchw2Nhwc() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(Nchw2Nhwc, PrimitiveC);
-  Nchw2Nhwc() = default;
   explicit Nchw2Nhwc(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
 #else
-  Nchw2Nhwc() = default;
-
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
   int InferShape(std::vector<lite::Tensor *> inputs_, std::vector<lite::Tensor *> outputs_) override;

mindspore/lite/src/ops/neg.h

@@ -27,14 +27,13 @@ namespace mindspore {
 namespace lite {
 class Neg : public ArithmeticSelf {
  public:
+  Neg() = default;
+  ~Neg() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(Neg, ArithmeticSelf);
-  Neg() = default;
   explicit Neg(schema::PrimitiveT *primitive) : ArithmeticSelf(primitive) {}
   int UnPackAttr(const Primitive &prim, const std::vector<AnfNodePtr> &inputs) override;
 #else
-  Neg() = default;
-
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
 };

mindspore/lite/src/ops/neg_grad.h

@@ -27,13 +27,12 @@ namespace mindspore {
 namespace lite {
 class NegGrad : public ArithmeticSelf {
  public:
+  NegGrad() = default;
+  ~NegGrad() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(NegGrad, ArithmeticSelf);
-  NegGrad() = default;
   explicit NegGrad(schema::PrimitiveT *primitive) : ArithmeticSelf(primitive) {}
 #else
-  NegGrad() = default;
-
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
 };

mindspore/lite/src/ops/nhwc2nchw.h

@@ -27,13 +27,12 @@ namespace mindspore {
 namespace lite {
 class Nhwc2Nchw : public PrimitiveC {
  public:
+  Nhwc2Nchw() = default;
+  ~Nhwc2Nchw() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(Nhwc2Nchw, PrimitiveC);
-  Nhwc2Nchw() = default;
   explicit Nhwc2Nchw(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
 #else
-  Nhwc2Nchw() = default;
-
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
   int InferShape(std::vector<lite::Tensor *> inputs_, std::vector<lite::Tensor *> outputs_) override;

mindspore/lite/src/ops/non_max_suppression.h

@@ -24,14 +24,13 @@ namespace mindspore {
 namespace lite {
 class NonMaxSuppression : public PrimitiveC {
  public:
+  NonMaxSuppression() = default;
+  ~NonMaxSuppression() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(NonMaxSuppression, PrimitiveC);
-  NonMaxSuppression() = default;
   explicit NonMaxSuppression(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
   void SetCenterPointBox(int centerPointBox);
 #else
-  NonMaxSuppression() = default;
-
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
   int InferShape(std::vector<lite::Tensor *> inputs_, std::vector<lite::Tensor *> outputs_) override;

mindspore/lite/src/ops/not_equal.h

@@ -27,13 +27,12 @@ namespace mindspore {
 namespace lite {
 class NotEqual : public Arithmetic {
  public:
+  NotEqual() = default;
+  ~NotEqual() = default;
 #ifdef PRIMITIVE_WRITEABLE
   MS_DECLARE_PARENT(NotEqual, Arithmetic);
-  NotEqual() = default;
   explicit NotEqual(schema::PrimitiveT *primitive) : Arithmetic(primitive) {}
 #else
-  NotEqual() = default;
-
   int UnPackToFlatBuilder(const schema::Primitive *primitive, flatbuffers::FlatBufferBuilder *fbb) override;
 #endif
   int InferShape(std::vector<lite::Tensor *> inputs_, std::vector<lite::Tensor *> outputs_) override;