プログラマーズ雑記帳

  Foo a;
  Foo b(a);  // コピーコンスタクター

  Foo a, c;
  c = a;     // 代入演算子

  Foo a;
  Foo d = a; // コピーコンスタクター

class Person
{
private:
    std::string m_name;
    int m_age;
    // :
};

C(const C &);
C &operator=(const C &);

class Person
{
  char *m_name;                         ///< 名前
  unsigned int m_age;                   ///< 年齢

public:
  /// コンストラクター
  Person(const char *name = 0, unsigned int age = 0)
      :m_name(0), m_age(age)
  {
    SetName(name);
  }

  /// デストラクター.
  virtual ~Person()
  {
    SetName(0);
  }


  /// コピーコンストラクター
  Person(const Person &other)
      :m_age(other.m_age)
  {
    SetName(other.m_name);
  }

  Person &operator=(const Person &other)
  {
    // 自身の代入チェック
    if (this != &other) {      
      SetName(other.m_name);
      m_age = other.m_age;
    }
    return *this;
  }

  // :  

};

  Person &operator=(const Person &other)
  {
      // :
    return *this;
  }

  Person &operator=(const Person &other)
  {
    // 自身の代入チェック
    if (this != &other) {      
        // :
    }
    return *this;
  }

class Student : public Person
{
  char *m_school;                         ///< 学校名

public:
  /// コンストラクター
  Student(const char *name = 0, unsigned int age = 0, const char *school = 0)
      :Person(name, age)
  {
    SetSchool(school);
  }

  /// デストラクター.
  virtual ~Student()
  {
    SetSchool(0);
  }

  /// コピーコンストラクター
  Student(const Student &other)
      :Person(other)
  {
    SetSchool(other.m_school);
  }

  Student &operator=(const Student &other)
  {
    // 自身の代入チェック
    if (this != &other) {
      // 基底クラスメンバーの代入
      Person::operator=(other);
      SetSchool(other.m_school);
    }
    return *this;
  }

  // :
  
};

  Student(const Student &other)
      :Person(other)  // 基底クラスのコピーコンスタクター
  {

  Student &operator=(const Student &other)
  {
      // :
      // 基底クラスメンバーの代入
      Person::operator=(other);
      SetSchool(other.m_school);

  Person(const Person &other)
  {
    *this = other;
  }

class Person
{  
 private:
  // コピー禁止
  Person(const Person &);
  void operator=(const Person &);

/// コピー禁止マクロ
/// @param C クラス名
#define NON_COPYABLE(C)       C(const C &);       \
                              void operator=(const C &)

class Person
{
 private:
  // コピー禁止(マクロ版)
  NON_COPYABLE(Person);

#include <boost/noncopyable.hpp>

class Person : boost::noncopyable
{

class Person
{
  public:
  // コピー禁止 (C++11)
   Person(const Person &) = delete;
   Person &operator=(const Person &) = delete;

/// コピー禁止マクロ (C++11)
/// @param C クラス名
#define NON_COPYABLE(C)         C& operator=(const C&) = delete;        \
                                C(const C&) = delete;