C++ Tips

静的な文字列リテラルは、同名のものは同じアドレスを示す

プログラム中に"hoge"のように記載する文字列リテラルは、リンク時に静的な領域にまとめられ、同一の文字列は一つにまとめられます。(ビルドオプションで設定) それを利用して、静的リテラルのアドレスをハッシュ値として扱うことができます。

#include <iostream> 

const char* s1 = "hoge";
const char* s2 = "hoge"; 

int main(int ac, char*av[]) { 
	const char* s3 = "hoge";
	std::cout << "s1 == s2     : " << (s1 == s2) << std::endl;
	std::cout << "s1 == s3     : " << (s1 == s3) << std::endl;
	std::cout << "s1 == 'hoge' : " << (s1 == "hoge") << std::endl;
} 

output

s1 == s2     : 1
s1 == s3     : 1
s1 == 'hoge' : 1

http://ideone.com/fJz5e

整数型配列の初期化

クラスインスタンスの整数型配列をゼロで初期化するには、初期化リストに記載するだけでよい。

before

class Hoge {
  int a[10];
  hoge() {
    memset(&a[0], 0, sizeof(a));
  }
}:

after

class Hoge {
  int a[10];
  hoge() : a() {
  }
}; 

http://ideone.com/E3rEc

多重継承したクラスをnewの配置構文で確保したときの落とし穴

多重継承したクラスのポインタは、親クラスのポインタにキャストした場合、アドレスが同一にならない。

class C : public A, public B {...}
C* c = new C;
assert((A*)c == (B*)c); // assertで停止

ポインタの値で比較するときは注意が必要。

同じ理由で、newの配置構文でクラスインスタンスを確保した場合、親クラスのポインタで削除すると不具合が発生する場合がある。

class C : public A, public B {...}
void* buffer = malloc(sizeof(C));
C* c = new(buffer) C;
B* b = c; // B*に代入
b->~B();  // ~B()がvirtualならば、デストラクタはA,Cとも正常に呼び出される
free(b); // bの値はbufferと異なるので死にます

↓ ideone.comでのサンプル
http://ideone.com/LdCNi

== true で比較してはいけない理由

if文で値をbooleanとして比較するとき、trueと==で比較すると、思わぬ落とし穴にはまることがある。

※ C++ では、intとbool値と比較しても、左辺値に対して暗黙の型変換は行われない。

#include <stdio.h>
int main(int ac, char* av[]) {
    int a = 2;
    if (a)          printf("a is true\n"); else printf("a is false\n");
    if (a == true)  printf("a is true\n"); else printf("a is false\n");
    if (a != false) printf("a is true\n"); else printf("a is false\n");
    if (static_cast<bool>(a) == true)
                    printf("a is true\n"); else printf("a is false\n");
    return 0;
}       

結果

a is true
a is false
a is true
a is true

"a == true" で比較したときだけ、結果が異なる。

http://ideone.com/UbvzC

仮想関数の部分オーバーライドについて

class Base {
public:
  virtual void hoge() = 0;
  virtual void hoge(int a) { printf("a=%d\n", a); }
};
class Sub : public Base {
public:
  virtual void hoge() { printf("hoge\n"); }
};

このように仮想関数を部分的にオーバーライドした場合、警告がでる。
回避するには、 class Subに、"using Base::hoge; "を加えるとよい。

本来なら同名のオーバーライドを避けるべきである。

http://stackoverflow.com/questions/2057823/issues-with-partial-class-function-overrides-in-c

#defineマクロとの戦い

#define hoge(x) HOGE(x)

などで、別名を無理やり定義されてしまっているのをすり抜ける方法。

コード例 (http://ideone.com/S44K6)

#include <stdio.h>
 
namespace foo {
void hoge(const char* const msg) { printf("small hoge : %s\n", msg); }
void HOGE(const char* const msg) { printf("LARGE HOGE : %s\n", msg); }
}
 
#define hoge(msg) HOGE(msg)
#define FOO
 
int main(int ac, char* av[]) {
        foo::hoge("ns::function");
        (foo::hoge)("(ns::function)");
        foo::hoge FOO("ns::function FOO");
};

output

LARGE HOGE : ns::function
small hoge : (ns::function)
small hoge : ns::function FOO

boost pool

orderedとは

通常版(非orederd)

ordered、非orderedともに一長一短で使いにくい

オーバーライドした関数の戻り値は、基本クラスの定義の戻り値を継承したものでもOK

#include <stdio.h>
 
struct Base {
        virtual Base* create() = 0; // create new instance
        virtual Base* clone() = 0;  // create and copy instance
        virtual void print() = 0;
};
 
struct Sub : Base {
        Sub() {}
        Sub(const Sub& sub) {} // copy constructor
        Sub* create() { return new Sub(); }
        Sub* clone() { return new Sub(*this); }
        void print() { printf("I am Sub\n"); }
};
 
int main(int ac, char* av[]) {
        Base* base1 = Sub().create();
        Base* base2 = base1->clone();
        base2->print();
        return 0;
}
 

boost:multiindexは便利

http://d.hatena.ne.jp/faith_and_brave/20091126/1259226643

virtualやポインタを使わず、サブクラスの生オブジェクトをコンテナに入れるためのクラス

   // BaseClassのサブクラスをコンテナにいれるためのクラス
   // このクラスを使うことで、ポインタを使わず動的ポリモーフィズムを実現する
   template <typename BaseClass, size_t MaxSize>
   struct DynamicPolymorphism : BaseClass {
       uint8_t body[MaxSize - sizeof(BaseClass)];
       DynamicPolymorphism() : BaseClass() {}
       DynamicPolymorphism(const DynamicPolymorphism& m) : BaseClass(m) {
           memcpy(body, m.body, sizeof(body));
       }
       template <typename SubClass>
       DynamicPolymorphism(const SubClass& m) : BaseClass(m) {
           SubClass& self = reinterpret_cast<SubClass&>(*this);
           self = m;
       }
       template <typename SubClass>
       void operator = (const SubClass& m) {
           SubClass& self = reinterpret_cast<SubClass&>(*this);
           self = m;
       }
       template <typename SubClass>
       operator SubClass& () { return reinterpret_cast<SubClass&>(*this); }
   };

※これでunionから開放されます

比較的サイズが小さいクラスを実体のままコンテナに格納する場合、継承したクラスオブジェクトを入れる事が難しい。手っ取り早い方法としては、unionを使う事があるが、unionを使うとコンストラクタが書けないなどのC++11以前の制約がある。

  class Car {
    int cylinders; /* 気筒数*/
    int displacement; /* 排気量 */ 
  };
  class Track : public Car { int payload = 1000; } // 最大積載量
  class Bus : public Car { int maxPeoples = 30; }  // 乗車定員
  vector<Car> carList;
  carList.push_back(Truck()); // NG  TruckがCarでスライシングされてpayloadが失われる
  carList.push_back(Bus()); // NG  BusがCarでスライシングされてmaxPeoplesが失われる
  vector<Car*> carList2;
  carList2.push_back(new Truck()); // OK  Truckの情報も保持される
  carList2.push_back(new Bus()); // OK  maxPeoplesの情報も保持される

ポインタを使えば解決するけど、小さいオブジェクトを全部newで作るのは効率が悪い。

unionを使った解決方法

 class AllCar {
   enum Type { Truck, Bus };
   Type type;
   int cylinders;
   int displacement;
   union {
      int payload;
      int maxPeoples;
   };
 };
 vector<AllCar> allCarList;
 AllCar truck;
 truck.type = AllCar::truck;
 allCarList.push_back(truck);

DynamicPolymorphismを使った例

class Car { 
   enum Type { Truck, Bus };
   Type type;
   int cylinders; /* 気筒数*/ int displacement; /* 排気量 */ };
};

  class Track : public Car { int payload = 1000; } // 最大積載量
  class Bus : public Car { int maxPeoples = 30; }  // 乗車定員
  typedef DynamicPolymorphism<Car, max(sizeof(Truck), sizeof(Bus))>  AllCars;
  
  vector<AllCars> allCars;
  allCars.push_back(Truck());  // AllCarsは継承クラスの最大サイズが確保されているのでスライシングは起こらない
  allCars.push_back(Bus());

  Truck& t = allCars.front(); // DynamicPolymorphismのオペレーターでTruckに変換される
  Bus& t = allCars[1];

operator new の効力範囲

#include <stdio.h>
#include <stdlib.h>
 
void* operator new (size_t sz) throw() {
	printf("global operator new\n");
	return 0;
} 
 
int main(int ac, char* av[]) {
	struct newtest {
		static void* operator new (size_t sz) throw() {
			printf("newtest operator new\n");
			return 0;
		}
		void dotest() {
			char* a = new char;
			printf("a = %p\n", a);	
		}
	};
	newtest t;
	t.dotest();
	newtest* t2 = new newtest;
};

実行結果

global operator new
a = (nil)
newtest operator new

参照型のメンバをもつクラスのコンテナとソート

参照型のインスタンスをもつクラスは、通常だとvector等のコンテナに格納できない。

 // 参照型のインスタスをもつクラス
 struct Hoge {
   int& instance_;
   Hoge(int& i) : instance_(i) {}
   Hoge(const Hoge& h) : instance_(h.instance_) {}
   bool operator < (const Hoge& h) const { return instance_ < h.instance_; }
 };

std::vectorに入れてみる

 std::vector<Hoge> vectorhoge;
 int h1 = 1;
 vectorhoge.push_back(h); // コンパイルエラー

operator =がないとvector::push_backはできない

listならOK

 std::list<Hoge> listhoge;
 int h1 = 1;
 listhoge.push_back(h); // OK

vectorに格納可能なリファレンスをもつクラスの定義

禁断の技その1

Hoge operator = (const Hoge& h) {
   memcpy(this, &h, sizeof(Hoge));
   return *this;
}
  1. thisのデストラクタが呼ばれないで破棄される
  2. オブジェクトのバイナリーコピーは非常に危険なのでダメ

禁断の技その2

Hoge operator = (const Hoge& h) {
  this->~Hoge();
  new (this) Hoge(h);
  return *this;
}
  1. いちおう、言語的には安全。
  2. ハーブ・サッターさんは絶対に使うなと警告している方法
  3. コピーコンストラクタとデストラクタで例外を投げないことが前提。例外が発生すると破綻する。
  4. スレッドセーフでもない。シングルスレッド限定。
  5. 自己代入の処理も必要
  6. 欠点は多いけど、これでvectorに対する要素の追加やsortが可能になる

コードの例

#include <cstdio> 
#include <list>
#include <vector>
#include <algorithm>
#include <functional>
#include <iostream>
 
// 参照を持つクラスのswap
namespace {

 struct Hoge {
    int& instance_;
    Hoge(int& i) : instance_(i)
    {}
    Hoge(const Hoge& h) : instance_(h.instance_) {}

    // コピーコンストラクタとnewの第二構文を使った初期化を使って実現する。
    // 例外安全ではない。デストラクタ・コピーコンストラクタが例外を投げない
    // スレッドセーフではない。スレッドセーフにするには排他処理が必要。
    Hoge& operator = (const Hoge& h) {
      if (this != &h) { // 自己代入でない
        this->~Hoge();       // thisを破棄 デストラクタは例外を投げない
        // ここで他のスレッドがthisを参照すると破綻する。シングルスレッド限定!
        try {
          new(this) Hoge(h);
        }
        catch (...) {
          assert(false); // 例外が投げられたら停止
        }
      }
      return *this;
    }

    // リファレンスタイプのインスタンスは通常の方法ではswapできないので、
    // コピーコンストラクタとnewの第二構文を使った代入の=を使って実現する。
    // 例外安全ではない。コピーコンストラクタが例外を投げないことが前提
    void swap(Hoge& h) {
      Hoge tmp(h);         // hをコピー
      h = *this;
      *this = tmp;
    }

    bool operator < (const Hoge& h) const { return instance_ < h.instance_; }

  };

  // output用
  void print(const Hoge& h) { printf("%d\n", h.instance_); }

}

        
int main(int argc, char* argv[])
{
  int i1 = 1;
  int i2 = 2;
  int i3 = 3;
  Hoge h1(i1), h2(i2), h3(i3);
  std::vector<Hoge> vectorhoge;  
  vectorhoge.push_back(h3); // operator =がないとvector::push_backはでき ない 
  vectorhoge.push_back(h2);
  vectorhoge.push_back(h1);
  std::back_inserter(vectorhoge) = h1;
  std::sort(vectorhoge.begin(), vectorhoge.end()); // operator =がないと vector::sortはできない
  std::cout << "vector sort" << std::endl;
  std::for_each(vectorhoge.begin(), vectorhoge.end(), print);

  std::list<Hoge> listhoge;
  listhoge.push_back(h3);
  listhoge.push_back(h2);
  listhoge.push_back(h1);
  std::back_inserter(listhoge) = h1;
  listhoge.sort();
  std::cout << "list sort" << std::endl;
  std::for_each(listhoge.begin(), listhoge.end(), print);

  return 0;
}

C++OPTIONAL


トップ   新規 一覧 単語検索 最終更新   ヘルプ   最終更新のRSS