Konstruktor kopiujacy

Chciałem się zapytać czy może być konstruktor kopiujący wypełniający drugi obiekt w liście inicjalizacyjnej a nie w ciele konstruktora ?

Może

class StringHolder
{
public:
    StringHolder() = default;
    StringHolder(const std::string &str)
       : _str(str) {}
    StringHolder(const StringHolder &other)
       : _str(other.GetString()) {}
 
    std::string GetString() const
    {
          return _str;
    }
 
private:
    std::string _str;
};

EDIT
Po uwadze @Satirev w komentarzu dodam - powyższy kod jest odpowiedzią na pytanie

czy może być
Nie jest to przykład w jaki sposób powinno się używać konstruktory kopiujące.

Nie tylko może, a nawet powinien. Tylko w ten sposób możesz skopiować stałe pola.

konstruktor wypełniający drugi obiekt? tak się raczej nie powinno robić

Nie bede robic nastepnego tematu wiec tutaj wrzuce kod mam dwa pytania :
Czy ta linijka jest poprawna Osoba(const Osoba & r):nazwisko(r.nazwisko),imie(r.imie),wiek(r.wiek), adres(r.adres?new Adres(*r.adres):0 ){}
Dlaczego nie jest zwalniana pamiec w operatorze przypisania?

#include<iostream>
#include<string>


using namespace std;

class Adres
{
private:
string miasto;
string kod; 
string ul;
int nr;

	public:
	
	Adres():nr(0){}
	Adres(const string& a1, const string& a2, const string &a3, const int a4):
	miasto(a1),kod(a2),ul(a3),nr(a4){}
	
	
	
	string& MIAS(){return miasto;}
	const string& MIAS()const{return miasto;}
	
	string & KOD(){return kod;}
	const string& KOD()const {return kod;}
	

	string& UL(){return ul;}
	const string& UL()const{return ul;}
	
	
	int& NR(){return nr;}
	const int& NR()const {return nr;}
	
~Adres(){}
};


ostream & operator<<(ostream& out, const Adres& r)
{
return out<<r.MIAS()<<" "<<r.KOD()<<" "<<r.UL()<<" "<<r.NR()<<endl;
}



class Osoba
{
private:
string nazwisko; 
string imie;
int wiek;
Adres *adres;

	public:
	Osoba():wiek(0),adres(new Adres){}
	
	Osoba(const string& b1, const string &b2, int b3, const Adres& b4):
	nazwisko(b1),imie(b2),wiek(b3), adres( new Adres(b4) ){}
	
	
	Osoba(const Osoba & r):
	nazwisko(r.nazwisko),imie(r.imie),wiek(r.wiek), adres(r.adres?new Adres(*r.adres):0 ){}	
	
	
	string& NAZ(){return nazwisko;}
	const string& NAZ()const{return nazwisko;}


	string& IMIE(){return imie;}
	const string& IMIE()const{return imie;}
	
	
	int& WIEK(){return wiek;}
	const int& WIEK()const {return wiek;}
	
	
	Adres* ADRES(){return adres;}
	const Adres* ADRES()const{return adres;}
		
 Osoba& operator=(const Osoba&);


~Osoba(){  delete adres; }	
};




Osoba& Osoba:: operator=(const Osoba &g) {
  if (this != &g) {

      nazwisko = g.nazwisko; 
      imie = g.imie;
      wiek = g.wiek;
     *adres = *g.adres;
	}

   return *this;
}


ostream & operator<<(ostream& out, const Osoba& r)
{
return out<<r.NAZ()<<" "<<r.IMIE()<<" "<<r.WIEK()<<" "<<*r.ADRES()<<endl;
}


int main()
{


  Adres a("Czestochowa","42-209","Dabrowskiego",73);
  
  cout<<a<<'\n';

  Adres a1(a);
  cout<<a1<<'\n';
  Adres a2;
  cout<<a2<<'\n';
  a2=a1;
  cout<<a2<<'\n';
  
  Osoba o("Iksinski","Roman", 45, a);
  cout<<o<<'\n';
  Osoba o1=o;
  cout<<o1<<'\n';
  Osoba o2;
  cout<<o2<<'\n';
  o2 = o1;
  cout<<o2<<'\n';

return 0;
}