学校の授業では構文は教えてくれるがその機能が何のためにあるかを教えてくれない。なぜだ。なぜなのだ。

そんなわけで、ここでは「クラスとは何で、使うと何がいいのか」について私なりの解釈を載せようと思う。

まず、かなり極端な例だが、以下のようなプログラムを考える。

//身長を入力する関数
double scanHeight(){
  double h;
  printf("身長を入力してください:");
  scanf("%lf",&h);
  return h;
}
//体重を入力する関数
double scanWeight(){
  double w;
  printf("体重を入力してください:");
  scanf("%lf",&w);
  return w;
}
//BMIを計算する
int main(){
   double HeightA = scanHeight();
   double WeightA = scanWeight();
   double HeightB = scanHeight();
   double WeightB = scanWeight();
   double BMI_A = WeightA*HeightA*HeightA;
   double BMI_B = WeightB*HeightB*HeightB;
}

このプログラムは正常に動作する（多分）。だが、コーディングという観点からみるとバグを生みやすい書き方をしているといえる。

以下のようなバグを作る可能性がある。

int main(){
   double HeightA = scanHeight();
   double WeightA = scanHeight();//コピペミスかなにか。コンパイルは通る
   double HeightB = scanHeight();
   double WeightB = scanWeight();
   double BMI_A = WeightA*HeightA*HeightA;
   double BMI_B = WeightB*HeightB*HeightB;
}

このようなバグを作った場合、実行時には三回連続で身長を聞かれてしまう。

ここで問題である。なぜこのソースコードがコンパイルを通るのか？

WeightAという変数を体重用の変数と考えているのも、scanHeightという関数を身長用の関数だととらえているのも、いずれも人間が勝手にそうだと言い張っているだけなのだ。コンピュータ（コンパイラ及びCPU）には、このプログラムは以下のように見える。

int main(){

   double型の変数１ = doubleを返す関数１();

   double型の変数２ = doubleを返す関数１();

   double型の変数３ = doubleを返す関数１

   double型の変数４ = doubleを返す関数２;

   double型の変数５ = 変数２*変数１*変数１;

   double型の変数６ = 変数４*変数３*変数３

}

変数名WeightAや関数名scanHeightはあくまで人間がわかりやすいように人間が勝手につけたものだ。コンピュータにとってはWeightAもHeightAも、double型の二つの変数、程度の違いしかない。

ここでもし、以下のように書けたら、きっとエラーが出るに違いない。

//身長を入力する関数
heightValue_t scanHeight(){...}
//体重を入力する関数
weightValue_t scanWeight(){...}
int main(){
   heightValue_t HeightA = scanHeight();
   weightValue_t WeightA = scanHeight();//エラー　WeightAは体重型だがscanHeightが返すのは身長の値
   heightValue_t HeightB = scanHeight();
   weightValue_t WeightB = scanWeight();
   bmiValue_t BMI_A = WeightA*HeightA*HeightA;
   bmiValue_t BMI_B = WeightB*HeightB*HeightB;
}

C++が扱えるデータの種類は文字コード(char)や小さな整数(short)や大きな整数(int)や小数(double)といった、「数値」だけである。

それだけでもプログラムを組むことはできるのだが、「体重」や「身長」や「人間」や「車」といった、現実に存在する様々な種類のデータを扱いたい。

データの種類を追加することで、現実世界に存在するモノに対する処理を、ソースコード上に、C++言語の文法で記述できるようにするための機能。

それがクラスなのである。

例えば、

class Apple{
   unsigned char Color[4];
   double weight;
};

というプログラムを書いたら、それは

このプログラムには「リンゴ」という種類（データ型）が定義されており、リンゴというモノ（インスタンス）には、色と重さがある

という日本語を、C++語に翻訳したことになるのだ。

続く...

シカゴミレニアムパークのモンロー港の写真。

行ってみたら凍っていていい味が出ていた。

C++11のunique_ptr<>。これ基本的な考え方は大したことないんだが物凄く便利だ。

関数内でメモリを確保するときは、スタック領域に確保するかヒープ領域に確保するかの二通りの考え方がある。

スタック領域に確保する場合：

メリット：スコープを抜けたときに自動で解放してくれる

デメリット：あまり大きなメモリは確保できない　,　サイズが固定である

ヒープ領域に確保(new)する場合：

メリット：大きなメモリを確保できる　,　実行時にサイズを指定できる

デメリット：明確なdeleteを忘れるとメモリリークを起こす

問題は、狭いスコープ内、例えば関数内、if文の{}内などでメモリを確保したくなり、サイズを実行時に指定したくしかも大きなサイズが必要というケースは頻繁にあるということだ。

少し余分に確保しておく、という方法が取れればそれでもいいが、そうでない限りnewを使うしかなくなる。すると同時にdeleteの義務が発生してしまうのである。

std::unique_ptrはこのような場合に用いることができる、

「スコープを抜けたら自動的に解放してくれるスタック変数のメリット」と

「大きな領域を動的に確保できるヒープのメリット」

を足したような素晴らしいポインタである。

#include <memory>
#pragma warning(disable:4996)
struct RGB {
unsigned char r;
unsigned char g;
unsigned char b;
};
int main()
{
int width;
int height;
scanf("%d %d", &width, &height);
bool makeimage = true;
//フラグが経っているときだけ画像を作成し、何かする
if (makeimage == true) {
std::unique_ptr<RGB[]> image = std::unique_ptr<RGB[]>(new RGB[width*height]);
for (int i = 0; i < width*height; i++) {
			image[i].r = 0;
			image[i].g = 0;
			image[i].b = 0;
}
}

    return 0;
}

このプログラムでは sizeof(char)×3×任意の値×任意の値　という、場合によっては巨大なメモリを動的に確保するが、delete [] の必要がない。書かなくても、ifブロックを抜けた時点で速やかに解放される。

GCではないので、コンピュータの気まぐれでいつ解放されるかわからない、という不安もついてこない。

----------------------

書きかけかも？

普通、光は水に入ると次第に減衰していく。だから極めて浅いところでは色がなく、浅いところでは明るい色になり、深いところでは暗い色になる。

ところがCyclesのGlassは光の減衰を再現してくれないらしい。だから薄く色を付けたGlassのオブジェクトを使うと沼みたいになる。

仕方がないのでVolumeを使用。表面には別に半透明なマテリアルを指定し、Voronoiで波を再現して貼り付けている。

C++のDLLの中に、関数ポインタを取る関数が外部に公開されている。

これをC#から使いたい。

どういうわけか、以下コードのCallFunctionに渡す関数ポインタの型をtypedefした関数ポインタ型(CallFP)にしたところランタイムエラーが起こる。

仕方がないので、void*で受け取って呼び出し直前にキャストするようにしたところうまくいった。今のところ、意味が分からない。

ちなみに、DLLDefs.hはDLL作成時に使用するヘッダで使っているもの。

dlltest.h

#include "DLLDefs.h"
#include <cstdint>
///////////////////////////////////
/// C++側 (ヘッダ) /////////////////
///////////////////////////////////
int APIENTRY DllMain(HINSTANCE hInstance, DWORD dwReason, LPVOID lpReserved);

typedef  void(WINAPI *CallFP)(std::int32_t a, std::int32_t b);

__DLL_PORT void WINAPI CallFunction(void* p,std::int32_t in1,std::int32_t in2);

dlltest.cpp

#include <Windows.h>
#include "dlltest.h"
///////////////////////////////////
/// C++側 (ｃｐｐ) /////////////////
///////////////////////////////////
int APIENTRY
DllMain(HINSTANCE hInstance, DWORD dwReason, LPVOID lpReserved)
{
  switch (dwReason) {
  case DLL_PROCESS_ATTACH:
    //初期処理
    break;
  case DLL_PROCESS_DETACH:
    //終了処理
    break;
  }

  return 1; // OK
};

void WINAPI CallFunction(void* p, std::int32_t in1, std::int32_t in2) {
  CallFP cp = static_cast<CallFP>(p);
  (*cp)(in1, in2);
}

using System;
using System.Runtime.InteropServices;//Marshal用
///////////////////////////////////
/// C#側 (呼び出し)/////////////////
///////////////////////////////////
namespace ConsoleApplication1
{
    //コールバック関数の型を宣言
    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
    delegate void TypeOfCallBack_t(System.Int32 a, System.Int32 b);

    class Program
    {
        //DLLの中の関数を宣言
        [DllImport("Project1.dll",EntryPoint = "CallFunction") ]
        public static extern void CallFunction(IntPtr callbk,Int32 in1,Int32 in2);

        //コールバック関数本体。この関数がＤＬＬ経由で呼び出される
        static public void CallBackMain(Int32 a, Int32 b)
        {
            Console.Write(a + b + "\n");
        }
        

        static TypeOfCallBack_t delgobj;
        static GCHandle gch;

        //エントリポイント
        public static void Main(string[] args)
        {
            delgobj = CallBackMain;
            IntPtr ptr = System.Runtime.InteropServices.Marshal.GetFunctionPointerForDelegate(
                delgobj
                );
            gch = GCHandle.Alloc(delgobj);

            //関数を呼び出す
            CallFunction( ptr ,10,15);

            Console.Read();

            gch.Free();
        }

    }
}