use '= default' when default functions should be used

src/CG-DNA/atom_vec_oxdna.cpp

@@ -52,9 +52,6 @@ AtomVecOxdna::AtomVecOxdna(LAMMPS *lmp) : AtomVec(lmp)
     error->warning(FLERR, "Write_data command requires newton on to preserve 3'->5' bond polarity");
 }
 
-/* ---------------------------------------------------------------------- */
-AtomVecOxdna::~AtomVecOxdna() {}
-
 /* ----------------------------------------------------------------------
    set local copies of all grow ptrs used by this class, except defaults
    needed in replicate when 2 atom classes exist and it calls pack_restart()

src/CG-DNA/atom_vec_oxdna.h

@@ -27,7 +27,7 @@ namespace LAMMPS_NS {
 class AtomVecOxdna : public AtomVec {
  public:
   AtomVecOxdna(class LAMMPS *);
-  ~AtomVecOxdna();
+  ~AtomVecOxdna() = default;
 
   void grow_pointers();
   void data_atom_post(int);

src/COMPRESS/dump_atom_gz.cpp

@@ -27,10 +27,6 @@ DumpAtomGZ::DumpAtomGZ(LAMMPS *lmp, int narg, char **arg) : DumpAtom(lmp, narg,
   if (!compressed) error->all(FLERR, "Dump atom/gz only writes compressed files");
 }
 
-/* ---------------------------------------------------------------------- */
-
-DumpAtomGZ::~DumpAtomGZ() {}
-
 /* ----------------------------------------------------------------------
    generic opening of a dump file
    ASCII or binary or compressed

src/COMPRESS/dump_atom_gz.h

@@ -28,7 +28,7 @@ namespace LAMMPS_NS {
 class DumpAtomGZ : public DumpAtom {
  public:
   DumpAtomGZ(class LAMMPS *, int, char **);
-  virtual ~DumpAtomGZ();
+  virtual ~DumpAtomGZ() = default;
 
  protected:
   GzFileWriter writer;

src/COMPRESS/dump_atom_zstd.cpp

@@ -33,10 +33,6 @@ DumpAtomZstd::DumpAtomZstd(LAMMPS *lmp, int narg, char **arg) : DumpAtom(lmp, na
   if (!compressed) error->all(FLERR, "Dump atom/zstd only writes compressed files");
 }
 
-/* ---------------------------------------------------------------------- */
-
-DumpAtomZstd::~DumpAtomZstd() {}
-
 /* ----------------------------------------------------------------------
    generic opening of a dump file
    ASCII or binary or compressed

src/COMPRESS/dump_atom_zstd.h

@@ -34,7 +34,7 @@ namespace LAMMPS_NS {
 class DumpAtomZstd : public DumpAtom {
  public:
   DumpAtomZstd(class LAMMPS *, int, char **);
-  virtual ~DumpAtomZstd();
+  virtual ~DumpAtomZstd() = default;
 
  protected:
   ZstdFileWriter writer;

src/COMPRESS/dump_cfg_gz.cpp

@@ -29,10 +29,6 @@ DumpCFGGZ::DumpCFGGZ(LAMMPS *lmp, int narg, char **arg) : DumpCFG(lmp, narg, arg
   if (!compressed) error->all(FLERR, "Dump cfg/gz only writes compressed files");
 }
 
-/* ---------------------------------------------------------------------- */
-
-DumpCFGGZ::~DumpCFGGZ() {}
-
 /* ----------------------------------------------------------------------
    generic opening of a dump file
    ASCII or binary or compressed

src/COMPRESS/dump_cfg_gz.h

@@ -28,7 +28,7 @@ namespace LAMMPS_NS {
 class DumpCFGGZ : public DumpCFG {
  public:
   DumpCFGGZ(class LAMMPS *, int, char **);
-  virtual ~DumpCFGGZ();
+  virtual ~DumpCFGGZ() = default;
 
  protected:
   GzFileWriter writer;

src/COMPRESS/dump_cfg_zstd.cpp

@@ -35,10 +35,6 @@ DumpCFGZstd::DumpCFGZstd(LAMMPS *lmp, int narg, char **arg) : DumpCFG(lmp, narg,
   if (!compressed) error->all(FLERR, "Dump cfg/zstd only writes compressed files");
 }
 
-/* ---------------------------------------------------------------------- */
-
-DumpCFGZstd::~DumpCFGZstd() {}
-
 /* ----------------------------------------------------------------------
    generic opening of a dump file
    ASCII or binary or compressed

src/COMPRESS/dump_cfg_zstd.h

@@ -33,7 +33,7 @@ namespace LAMMPS_NS {
 class DumpCFGZstd : public DumpCFG {
  public:
   DumpCFGZstd(class LAMMPS *, int, char **);
-  virtual ~DumpCFGZstd();
+  virtual ~DumpCFGZstd() = default;
 
  protected:
   ZstdFileWriter writer;

src/COMPRESS/dump_custom_gz.cpp

@@ -27,10 +27,6 @@ DumpCustomGZ::DumpCustomGZ(LAMMPS *lmp, int narg, char **arg) : DumpCustom(lmp,
   if (!compressed) error->all(FLERR, "Dump custom/gz only writes compressed files");
 }
 
-/* ---------------------------------------------------------------------- */
-
-DumpCustomGZ::~DumpCustomGZ() {}
-
 /* ----------------------------------------------------------------------
    generic opening of a dump file
    ASCII or binary or compressed

src/COMPRESS/dump_custom_gz.h

@@ -28,7 +28,7 @@ namespace LAMMPS_NS {
 class DumpCustomGZ : public DumpCustom {
  public:
   DumpCustomGZ(class LAMMPS *, int, char **);
-  virtual ~DumpCustomGZ();
+  virtual ~DumpCustomGZ() = default;
 
  protected:
   GzFileWriter writer;

src/COMPRESS/dump_custom_zstd.cpp

@@ -37,12 +37,6 @@ DumpCustomZstd::DumpCustomZstd(LAMMPS *lmp, int narg, char **arg) :
     error->all(FLERR,"Dump custom/zstd only writes compressed files");
 }
 
-/* ---------------------------------------------------------------------- */
-
-DumpCustomZstd::~DumpCustomZstd()
-{
-}
-
 /* ----------------------------------------------------------------------
    generic opening of a dump file
    ASCII or binary or compressed

src/COMPRESS/dump_custom_zstd.h

@@ -34,7 +34,7 @@ namespace LAMMPS_NS {
 class DumpCustomZstd : public DumpCustom {
  public:
   DumpCustomZstd(class LAMMPS *, int, char **);
-  virtual ~DumpCustomZstd();
+  virtual ~DumpCustomZstd() = default;
 
  protected:
   ZstdFileWriter writer;

src/COMPRESS/dump_local_gz.cpp

@@ -27,10 +27,6 @@ DumpLocalGZ::DumpLocalGZ(LAMMPS *lmp, int narg, char **arg) : DumpLocal(lmp, nar
   if (!compressed) error->all(FLERR, "Dump local/gz only writes compressed files");
 }
 
-/* ---------------------------------------------------------------------- */
-
-DumpLocalGZ::~DumpLocalGZ() {}
-
 /* ----------------------------------------------------------------------
    generic opening of a dump file
    ASCII or binary or compressed

src/COMPRESS/dump_local_gz.h

@@ -28,7 +28,7 @@ namespace LAMMPS_NS {
 class DumpLocalGZ : public DumpLocal {
  public:
   DumpLocalGZ(class LAMMPS *, int, char **);
-  virtual ~DumpLocalGZ();
+  virtual ~DumpLocalGZ() = default;
 
  protected:
   GzFileWriter writer;

src/COMPRESS/dump_local_zstd.cpp

@@ -33,10 +33,6 @@ DumpLocalZstd::DumpLocalZstd(LAMMPS *lmp, int narg, char **arg) : DumpLocal(lmp,
   if (!compressed) error->all(FLERR, "Dump local/zstd only writes compressed files");
 }
 
-/* ---------------------------------------------------------------------- */
-
-DumpLocalZstd::~DumpLocalZstd() {}
-
 /* ----------------------------------------------------------------------
    generic opening of a dump file
    ASCII or binary or compressed

src/COMPRESS/dump_local_zstd.h

@@ -34,7 +34,7 @@ namespace LAMMPS_NS {
 class DumpLocalZstd : public DumpLocal {
  public:
   DumpLocalZstd(class LAMMPS *, int, char **);
-  virtual ~DumpLocalZstd();
+  virtual ~DumpLocalZstd() = default;
 
  protected:
   ZstdFileWriter writer;

src/COMPRESS/dump_xyz_gz.cpp

@@ -26,10 +26,6 @@ DumpXYZGZ::DumpXYZGZ(LAMMPS *lmp, int narg, char **arg) : DumpXYZ(lmp, narg, arg
   if (!compressed) error->all(FLERR, "Dump xyz/gz only writes compressed files");
 }
 
-/* ---------------------------------------------------------------------- */
-
-DumpXYZGZ::~DumpXYZGZ() {}
-
 /* ----------------------------------------------------------------------
    generic opening of a dump file
    ASCII or binary or compressed

src/COMPRESS/dump_xyz_gz.h

@@ -28,7 +28,7 @@ namespace LAMMPS_NS {
 class DumpXYZGZ : public DumpXYZ {
  public:
   DumpXYZGZ(class LAMMPS *, int, char **);
-  virtual ~DumpXYZGZ();
+  virtual ~DumpXYZGZ() = default;
 
  protected:
   GzFileWriter writer;

src/COMPRESS/dump_xyz_zstd.cpp

@@ -32,10 +32,6 @@ DumpXYZZstd::DumpXYZZstd(LAMMPS *lmp, int narg, char **arg) : DumpXYZ(lmp, narg,
   if (!compressed) error->all(FLERR, "Dump xyz/zstd only writes compressed files");
 }
 
-/* ---------------------------------------------------------------------- */
-
-DumpXYZZstd::~DumpXYZZstd() {}
-
 /* ----------------------------------------------------------------------
    generic opening of a dump file
    ASCII or binary or compressed

src/COMPRESS/dump_xyz_zstd.h

@@ -34,7 +34,7 @@ namespace LAMMPS_NS {
 class DumpXYZZstd : public DumpXYZ {
  public:
   DumpXYZZstd(class LAMMPS *, int, char **);
-  virtual ~DumpXYZZstd();
+  virtual ~DumpXYZZstd() = default;
 
  protected:
   ZstdFileWriter writer;

src/DIELECTRIC/fix_polarize_bem_icc.cpp

@@ -93,10 +93,6 @@ FixPolarizeBEMICC::FixPolarizeBEMICC(LAMMPS *lmp, int narg, char **arg) : Fix(lm
 
 /* ---------------------------------------------------------------------- */
 
-FixPolarizeBEMICC::~FixPolarizeBEMICC() {}
-
-/* ---------------------------------------------------------------------- */
-
 int FixPolarizeBEMICC::setmask()
 {
   int mask = 0;

src/DIELECTRIC/fix_polarize_bem_icc.h

@@ -27,7 +27,7 @@ namespace LAMMPS_NS {
 class FixPolarizeBEMICC : public Fix {
  public:
   FixPolarizeBEMICC(class LAMMPS *, int, char **);
-  ~FixPolarizeBEMICC();
+  ~FixPolarizeBEMICC() = default;
   virtual int setmask();
   virtual void init();
   virtual void setup(int);

src/DPD-MESO/fix_edpd_source.cpp

@@ -61,12 +61,6 @@ FixEDPDSource::FixEDPDSource(LAMMPS *lmp, int narg, char **arg) :
 
 /* ---------------------------------------------------------------------- */
 
-FixEDPDSource::~FixEDPDSource()
-{
-}
-
-/* ---------------------------------------------------------------------- */
-
 int FixEDPDSource::setmask()
 {
   int mask = 0;

src/DPD-MESO/fix_edpd_source.h

@@ -27,7 +27,7 @@ namespace LAMMPS_NS {
 class FixEDPDSource : public Fix {
  public:
   FixEDPDSource(class LAMMPS *, int, char **);
-  ~FixEDPDSource();
+  ~FixEDPDSource() = default;
   int setmask();
   void init();
   void post_force(int);

src/DPD-MESO/fix_tdpd_source.cpp

@@ -62,12 +62,6 @@ FixTDPDSource::FixTDPDSource(LAMMPS *lmp, int narg, char **arg) :
 
 /* ---------------------------------------------------------------------- */
 
-FixTDPDSource::~FixTDPDSource()
-{
-}
-
-/* ---------------------------------------------------------------------- */
-
 int FixTDPDSource::setmask()
 {
   int mask = 0;

src/DPD-MESO/fix_tdpd_source.h

@@ -27,7 +27,7 @@ namespace LAMMPS_NS {
 class FixTDPDSource : public Fix {
  public:
   FixTDPDSource(class LAMMPS *, int, char **);
-  ~FixTDPDSource();
+  ~FixTDPDSource() = default;
   int setmask();
   void init();
   void post_force(int);

src/DPD-REACT/nbin_ssa.cpp

@@ -34,10 +34,6 @@ NBinSSA::NBinSSA(LAMMPS *lmp) : NBinStandard(lmp)
   }
 }
 
-NBinSSA::~NBinSSA()
-{
-}
-
 /* ----------------------------------------------------------------------
    bin owned and ghost atoms for the Shardlow Splitting Algorithm (SSA)
    local atoms are in distinct bins (binhead[]) from the ghosts

src/DPD-REACT/nbin_ssa.h

@@ -41,7 +41,7 @@ class NBinSSA : public NBinStandard {
   int lbinzhi;    // highest local bin z-dim coordinate
 
   NBinSSA(class LAMMPS *);
-  ~NBinSSA();
+  virtual ~NBinSSA() = default;
 
   void bin_atoms_setup(int);
   void bin_atoms();

src/KSPACE/ewald_dipole_spin.cpp

@@ -51,12 +51,6 @@ EwaldDipoleSpin::EwaldDipoleSpin(LAMMPS *lmp) :
   mub2mu0hbinv = mub2mu0 / hbar;                // in rad.THz
 }
 
-/* ----------------------------------------------------------------------
-   free all memory
-------------------------------------------------------------------------- */
-
-EwaldDipoleSpin::~EwaldDipoleSpin() {}
-
 /* ----------------------------------------------------------------------
    called once before run
 ------------------------------------------------------------------------- */

src/KSPACE/ewald_dipole_spin.h

@@ -27,7 +27,7 @@ namespace LAMMPS_NS {
 class EwaldDipoleSpin : public EwaldDipole {
  public:
   EwaldDipoleSpin(class LAMMPS *);
-  virtual ~EwaldDipoleSpin();
+  virtual ~EwaldDipoleSpin() = default;
   void init();
   void setup();
   void compute(int, int);

src/LATBOLTZ/fix_lb_viscous.cpp

@@ -55,13 +55,6 @@ FixLbViscous::FixLbViscous(LAMMPS *lmp, int narg, char **arg) :
   }
 
 
-}
-
-/* ---------------------------------------------------------------------- */
-
-FixLbViscous::~FixLbViscous()
-{
-
 }
 
 /* ---------------------------------------------------------------------- */

src/LATBOLTZ/fix_lb_viscous.h

@@ -27,7 +27,7 @@ namespace LAMMPS_NS {
 class FixLbViscous : public Fix {
  public:
   FixLbViscous(class LAMMPS *, int, char **);
-  ~FixLbViscous();
+  virtual ~FixLbViscous() = default;
   int setmask();
   void init();
   void setup(int);

src/MANIFOLD/manifold_thylakoid_shared.cpp

@@ -90,11 +90,6 @@ thyla_part::thyla_part( int type, double *args, double xlo, double ylo, double z
   z0 = (type == THYLA_TYPE_SPHERE) ? params[3] : params[5];
 }
 
-
-
-thyla_part::~thyla_part()
-{}
-
 double thyla_part::g(const double *x)
 {
   switch(type) {

src/MANIFOLD/manifold_thylakoid_shared.h

@@ -33,7 +33,7 @@ namespace user_manifold {
     thyla_part(int type, double *args, double xlo, double ylo, double zlo, double xhi, double yhi,
                double zhi);
     thyla_part() : type(-1), x0(-1337), y0(-1337), z0(-1337) {}
-    ~thyla_part();
+    ~thyla_part() = default;
 
     double g(const double *x);
     void n(const double *x, double *n);

src/MESONT/pair_mesont_tpm.cpp

@@ -38,7 +38,7 @@ using namespace LAMMPS_NS;
 class MESONTList {
 public:
   MESONTList(const Atom* atom, const NeighList* nblist);
-  ~MESONTList() {};
+  ~MESONTList() = default;;
   //list of segments
   const std::vector<std::array<int,2>>& get_segments() const;
   //list of triplets

src/ML-IAP/mliap_model_linear.cpp

@@ -31,10 +31,6 @@ MLIAPModelLinear::MLIAPModelLinear(LAMMPS* lmp, char* coefffilename) :
   if (nparams > 0) ndescriptors = nparams - 1;
 }
 
-/* ---------------------------------------------------------------------- */
-
-MLIAPModelLinear::~MLIAPModelLinear() {}
-
 /* ----------------------------------------------------------------------
    get number of parameters
    ---------------------------------------------------------------------- */

src/ML-IAP/mliap_model_linear.h

@@ -21,7 +21,7 @@ namespace LAMMPS_NS {
 class MLIAPModelLinear : public MLIAPModelSimple {
  public:
   MLIAPModelLinear(LAMMPS *, char * = nullptr);
-  ~MLIAPModelLinear();
+  ~MLIAPModelLinear() = default;
   virtual int get_nparams();
   virtual int get_gamma_nnz(class MLIAPData *);
   virtual void compute_gradients(class MLIAPData *);

src/ML-IAP/mliap_model_quadratic.cpp

@@ -34,10 +34,6 @@ MLIAPModelQuadratic::MLIAPModelQuadratic(LAMMPS* lmp, char* coefffilename) :
   nonlinearflag = 1;
 }
 
-/* ---------------------------------------------------------------------- */
-
-MLIAPModelQuadratic::~MLIAPModelQuadratic() {}
-
 /* ----------------------------------------------------------------------
    get number of parameters
    ---------------------------------------------------------------------- */

src/ML-IAP/mliap_model_quadratic.h

@@ -21,7 +21,7 @@ namespace LAMMPS_NS {
 class MLIAPModelQuadratic : public MLIAPModelSimple {
  public:
   MLIAPModelQuadratic(LAMMPS *, char * = nullptr);
-  ~MLIAPModelQuadratic();
+  ~MLIAPModelQuadratic() = default;
   virtual int get_nparams();
   virtual int get_gamma_nnz(class MLIAPData *);
   virtual void compute_gradients(class MLIAPData *);

src/OPENMP/pair_lj_cut_coul_cut_dielectric_omp.cpp

@@ -41,10 +41,6 @@ PairLJCutCoulCutDielectricOMP::PairLJCutCoulCutDielectricOMP(LAMMPS *lmp) :
 
 /* ---------------------------------------------------------------------- */
 
-PairLJCutCoulCutDielectricOMP::~PairLJCutCoulCutDielectricOMP() {}
-
-/* ---------------------------------------------------------------------- */
-
 void PairLJCutCoulCutDielectricOMP::compute(int eflag, int vflag)
 {
   ev_init(eflag, vflag);

src/OPENMP/pair_lj_cut_coul_cut_dielectric_omp.h

@@ -28,7 +28,7 @@ namespace LAMMPS_NS {
 class PairLJCutCoulCutDielectricOMP : public PairLJCutCoulCutDielectric, public ThrOMP {
  public:
   PairLJCutCoulCutDielectricOMP(class LAMMPS *);
-  virtual ~PairLJCutCoulCutDielectricOMP();
+  virtual ~PairLJCutCoulCutDielectricOMP() = default;
   virtual void compute(int, int);
 
  protected:

src/OPENMP/pair_lj_cut_coul_long_dielectric_omp.cpp

@@ -47,10 +47,6 @@ PairLJCutCoulLongDielectricOMP::PairLJCutCoulLongDielectricOMP(LAMMPS *lmp) :
 
 /* ---------------------------------------------------------------------- */
 
-PairLJCutCoulLongDielectricOMP::~PairLJCutCoulLongDielectricOMP() {}
-
-/* ---------------------------------------------------------------------- */
-
 void PairLJCutCoulLongDielectricOMP::compute(int eflag, int vflag)
 {
   ev_init(eflag, vflag);

src/OPENMP/pair_lj_cut_coul_long_dielectric_omp.h

@@ -29,7 +29,7 @@ class PairLJCutCoulLongDielectricOMP : public PairLJCutCoulLongDielectric, publi
 
  public:
   PairLJCutCoulLongDielectricOMP(class LAMMPS *);
-  virtual ~PairLJCutCoulLongDielectricOMP();
+  virtual ~PairLJCutCoulLongDielectricOMP() = default;
   virtual void compute(int, int);
 
  protected:

src/OPENMP/pair_lubricate_omp.cpp

@@ -47,11 +47,6 @@ PairLubricateOMP::PairLubricateOMP(LAMMPS *lmp) :
 
 /* ---------------------------------------------------------------------- */
 
-PairLubricateOMP::~PairLubricateOMP()
-{}
-
-/* ---------------------------------------------------------------------- */
-
 void PairLubricateOMP::compute(int eflag, int vflag)
 {
   ev_init(eflag,vflag);

src/OPENMP/pair_lubricate_omp.h

@@ -33,7 +33,7 @@ class PairLubricateOMP : public PairLubricate, public ThrOMP {
 
  public:
   PairLubricateOMP(class LAMMPS *);
-  virtual ~PairLubricateOMP();
+  virtual ~PairLubricateOMP() = default;
 
   virtual void compute(int, int);
   virtual double memory_usage();

src/OPENMP/pair_lubricate_poly_omp.cpp

@@ -47,11 +47,6 @@ PairLubricatePolyOMP::PairLubricatePolyOMP(LAMMPS *lmp) :
 
 /* ---------------------------------------------------------------------- */
 
-PairLubricatePolyOMP::~PairLubricatePolyOMP()
-{}
-
-/* ---------------------------------------------------------------------- */
-
 void PairLubricatePolyOMP::compute(int eflag, int vflag)
 {
   ev_init(eflag,vflag);

src/OPENMP/pair_lubricate_poly_omp.h

@@ -33,7 +33,7 @@ class PairLubricatePolyOMP : public PairLubricatePoly, public ThrOMP {
 
  public:
   PairLubricatePolyOMP(class LAMMPS *);
-  virtual ~PairLubricatePolyOMP();
+  virtual ~PairLubricatePolyOMP() = default;
 
   virtual void compute(int, int);
   virtual double memory_usage();

src/SPIN/pair_spin.cpp

@@ -53,10 +53,6 @@ PairSpin::PairSpin(LAMMPS *lmp) : Pair(lmp), emag(nullptr)
   lattice_flag = 0;
 }
 
-/* ---------------------------------------------------------------------- */
-
-PairSpin::~PairSpin() {}
-
 /* ----------------------------------------------------------------------
    global settings
 ------------------------------------------------------------------------- */

src/SPIN/pair_spin.h

@@ -23,7 +23,7 @@ class PairSpin : public Pair {
 
  public:
   PairSpin(class LAMMPS *);
-  virtual ~PairSpin();
+  virtual ~PairSpin() = default;
   virtual void settings(int, char **);
   virtual void coeff(int, char **) {}
   virtual void init_style();

src/lmppython.cpp

@@ -38,10 +38,6 @@ Python::~Python()
 
 /* ---------------------------------------------------------------------- */
 
-PythonInterface::~PythonInterface() {}
-
-/* ---------------------------------------------------------------------- */
-
 void Python::init()
 {
 #if defined(LMP_PYTHON)

src/lmppython.h

@@ -20,7 +20,7 @@ namespace LAMMPS_NS {
 
 class PythonInterface {
  public:
-  virtual ~PythonInterface();
+  virtual ~PythonInterface() = default;
   virtual void command(int, char **) = 0;
   virtual void invoke_function(int, char *) = 0;
   virtual int find(const char *) = 0;

src/table_file_reader.cpp

@@ -30,9 +30,6 @@ TableFileReader::TableFileReader(LAMMPS *lmp,
 {
 }
 
-TableFileReader::~TableFileReader() {
-}
-
 char *TableFileReader::find_section_start(const std::string &keyword) {
   char *line = nullptr;
   while ((line = reader->next_line())) {

src/table_file_reader.h

@@ -25,7 +25,7 @@ class TableFileReader : public PotentialFileReader {
  public:
   TableFileReader(class LAMMPS *lmp, const std::string &filename, const std::string &type,
                   const int auto_convert = 0);
-  virtual ~TableFileReader();
+  virtual ~TableFileReader() = default;
 
   char *find_section_start(const std::string &keyword);
 };

src/tokenizer.cpp

@@ -198,9 +198,6 @@ std::vector<std::string> Tokenizer::as_vector() {
 ValueTokenizer::ValueTokenizer(const std::string &str, const std::string &separators) : tokens(str, separators) {
 }
 
-ValueTokenizer::ValueTokenizer(const ValueTokenizer &rhs) : tokens(rhs.tokens) {
-}
-
 ValueTokenizer::ValueTokenizer(ValueTokenizer &&rhs) : tokens(std::move(rhs.tokens)) {
 }
 

src/tokenizer.h

@@ -97,7 +97,7 @@ class ValueTokenizer {
  public:
   ValueTokenizer(const std::string &str,
                  const std::string &separators = TOKENIZER_DEFAULT_SEPARATORS);
-  ValueTokenizer(const ValueTokenizer &);
+  ValueTokenizer(const ValueTokenizer &) = default;
   ValueTokenizer(ValueTokenizer &&);
   ValueTokenizer &operator=(const ValueTokenizer &);
   ValueTokenizer &operator=(ValueTokenizer &&);