常連

### 前提・実現したいこと

C言語でCSVへの書き出しを行いたいのですが，うまくいきません．
エラーメッセージとかは特になく，計算が終わったと思ったらファイルが作れていないという感じです．
わかる方がいらっしゃればご教示いただけないでしょうか．

### 該当のソースコード

＃include < stdio.h >
＃define _USE_MATH_DEFINES
＃include < math.h >
＃include < direct.h >

＃define NX 100
＃define NY 100
＃define NZ 100
＃define NT 100000
＃define Tmax 3.0

void main(void)
{
	double t[NX + 2][NY + 2][NZ + 2][2], f[NT + 2], dt, dx, r, a, time, pp, cp, lam, rho, tm, tinf, ss, phi, ep, sig, eta, dd, ff, p1, p2, rs, x, y, z, x1, y1, z1, xmax, ymax, zmax, t0, dy, dz;
	int i, j, k, imax, jmax, kmax, n;
	FILE* fp;transfer\thrust.csv", "w");
	fopen_s(&fp, "C:\Users\Public\thrust.csv", "w");
	dd = 1.63e-3;
	xmax = 2.0e-3;
	ymax = 2.0e-3;
	zmax = 2.0e-3;
	rs = dd / 2;
	dt = Tmax / (double)NT;
	dx = xmax / (double)NX;
	dy = ymax / (double)NY;
	dz = zmax / (double)NZ;
	imax = NX;
	jmax = NY;
	kmax = NZ;
	r = dt / dx / dx;
	time = 0;
	tm = 1850 + 273;
	tinf = 1750 + 273;
	t0 = 30 + 273;
	phi = 0.7e-3;
	ss = 0.25 * M_PI * pow(phi, 2);
	ep = 0.32;
	sig = 5.67e-8;
	eta = 0.0464;
	x = 0;
	y = 0;
	z = 0;
	x1 = xmax/2;
	y1 = ymax / 2;
	z1 = zmax / 2;
	fprintf(fp, "x,y,z,T\n");
	//初期条件
	//fprintf(fp, "0,");
	for (i = 0; i <= imax; i++){
		y = 0;
		for (j = 0; j <= jmax; j++) {
			z = 0;
			for (k = 0; k <= kmax; k++) {
				if (z >= z1 - sqrt(pow(rs, 2) - pow((y - y1), 2) - pow((x - x1), 2)) && z <= z1 + sqrt(pow(rs, 2) - pow((y - y1), 2) - pow((x - x1), 2))) t[i][j][k][0] = tinf;
				
				else t[i][j][k][0]=t0;
				fprintf(fp, "%8.3e,", i * dx);
				fprintf(fp, "%8.3e,", j * dy);
				fprintf(fp, "%8.3e,", k * dz);
				fprintf(fp, "%8.3e\n", t[i][j][k][0]);
				z=z+dz;
			}
			y=y+dy;
		}
		x=x+dx;
	}

	fclose(fp);
	
	return 0;
}

### 試したこと

**NX，NY，NZをそれぞれ10に設定したときはきちんとファイルが作れます．**
また，fopen_sの部分でprintfによる書き出しを行ってみたのですが，書き出しがされなかったので，その前の部分（かなり冒頭部分）で計算が終わってしまっていると考えられます．

###環境
Visual studio 2019

CSVファイルの作成・書き出し

makefileに関する質問です。
clean:の後につく;はどういった意味でしょうか。
調べても出てきません
よろしくお願いいたします。

```Makefile
clean:;		rm -f *.o
```

makefileの質問

最近、コンストラクタ・デストラクタについて

- デフォルトコンストラクタとは実引数の指定が不要なコンストラクタのこと
- デフォルトコンストラクタを定義しないと、空のデフォルトコンストラクタがコンパイラによって生成されること
- 仮引数を持つコンストラクタがあると、デフォルトコンストラクタを自身で定義しなければならないこと

の以上3点を学びました。

コンストラクタ・デストラクタを用いて、プログラムの実行時間を表示するクラス(?)を作ってみたのですが、このクラス(下記参照)は仮引数を持つコンストラクタがあるにもかかわらず、デフォルトコンストラクタを自身で定義しなくとも、問題なくコンパイル(g++)・実行できてしまいました。

---

質問:
この場合、```measure(option flag) {...} ```がこのクラス(?)のデフォルトコンストラクタとして扱われていると考えてよいのでしょうか。
仮にその場合、実引数の指定があるにもかかわらず、何故```measure(option flag) {...} ```がデフォルトコンストラクタとして扱われているのでしょうか。
私はプログラミング初心者なので、記法をはじめとして、このコードに対する指摘・アドバイスなどあればそれも併せて教えていただけると幸いです。
よろしくお願いします。

---

```C++
#include <iostream>
#include <chrono>

namespace function {
    enum option : bool {
        able = true,
        disable = false
    };
    struct measure {
        measure(option flag) {
            _flag = flag;
            if(flag) {
                start = std::chrono::steady_clock::now();
            }
        }
        ~measure() {
            if(_flag) {
                end = std::chrono::steady_clock::now();
                elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
                std::cout << "\ntime: " << elapsed.count() << " ms" << std::endl;  
            }
        }
        private:
            option _flag;
            std::chrono::steady_clock::time_point start, end;
            std::chrono::milliseconds elapsed;
    }; 
}

int main() {
    function::measure(function::able);
        // action
    return 0;
}
```

```Output

time: 0 ms
```

コンストラクタがデフォルトコンストラクタとして機能する条件を詳しく知りたい

英文から単語を一つずつ取ってきて、文書内の単語一覧とその出現回数を、線形リストを用いて作成したいです。
その際、単語の並べ方を辞書順（アルファベット）にしたいのですが、stricmp関数を用いて0のとき、0より大きいとき、0より小さいときで場合分けをしても、
```
his name is taro.
her name is hanako.
```
という文章に対して、
```
his : 1
hanako : 1
is : 2
name : 2
her : 1
taro : 1
```
と出力されてしまいます。
```
hanako : 1
her : 1
his : 1
is : 2
name : 2
taro : 1
```
と出力したいです。

stricmp関数でこれを実現することは可能でしょうか？

辞書順ソートを実現したい

C++でクラスを作成した際にそのクラスをvectorに保存して使おうと思っているのですが
クラスをnewして使用したとき、
クラスをnewしないで使用したときに
ずいぶんと速度差が出ました
クラスをデストラクタで破棄しないと言うことがわかっているときは、newしない方がいいのでしょうか

実験したのはVisual Studioで以下のコードです
私のPCでは大体
newしなかった場合の時間:0.37秒.
newした場合の時間:0.47秒.
位の時間が掛かっています(newした方とnewしなかった方と入れ替えても速度差は変わらりませんでした)

ctestdata.h
```
class ctestdata
{
private:
	int _a;
public:
	void setA(int a);
	void addA();
	int getA();
};
```
ctestdata.cpp
```
//とりあえずテストコード
void ctestdata::setA(int a)
{
	_a = a;
}

void ctestdata::addA()
{
	for (int i = 0; i < 100; i++) {
		_a++;
	}
}

int ctestdata::getA()
{
	return _a;
}
```
main.cpp
```
int main()
{
	int loopMax = 1000000;
	//--------------------------------------------------------------------------------------------
	std::vector <ctestdata> cbv;
	clock_t start2 = clock();    // スタート時間
	for (int i = 0; i < loopMax; i++) {
		ctestdata  cb;
		cb.setA(1);
		cb.addA();
		cbv.push_back(cb);
	}
	clock_t end2 = clock();     // 終了時間
	std::cout << "newしなかった場合の時間:" << (double)(end2 - start2) / CLOCKS_PER_SEC << "秒.\r\n";

	//--------------------------------------------------------------------------------------------
	std::vector <ctestdata*> cav;
	clock_t start = clock();    // スタート時間
	for (int i = 0; i < loopMax; i++) {
		ctestdata* ca = new ctestdata();
		ca->setA(i);
		ca->addA();
		cav.push_back(ca);
	}
	clock_t end = clock();     // 終了時間
	std::cout << "newした場合の時間:" << (double)(end - start) / CLOCKS_PER_SEC << "秒.\r\n";
}
```

C++でクラスをnewしたときとnewしないで使用したときの速度差

### 前提・実現したいこと
別cppファイルに記載したクラス同士でインスタンスを持ち合いたい

お世話になっております。Windows10にてC++の勉強をしております。
VS2019にて下記のソースコードのように、別cppファイルに記載したクラスの
インスタンスを持ち合いたいと思い、それぞれにお互いのcppをインクルードし
インスタンスを作成しています。
IDE上ではエラーは起きませんが、ビルドを行うと下記の試したことに出るような
コンパイルエラーが出てしまいコンパイルできません。

コンパイルエラーにならず、別cppに記載されたクラスがお互いに
インスタンスを持ち合うにはどう記述すればいいでしょうか？
お手数をおかけしますが何卒ご教示頂きたく宜しくお願いいたします。


なお、ヘッダーを定義して同様のことをしても、結局循環参照になって
しまうのでは？と思い実施していません。



### 発生している問題・エラーメッセージ

```
後述の「試したこと」を参照願います。
```

### 該当のソースコード

a.cpp
```c++
#pragma once
#include "b.cpp"

class a {
public:
	a() {
		b* f = new b();
	}
};

```

b.cpp
```c++
#pragma once
#include "a.cpp"

class b {
public:
	b() {
		a* f = new a();
	}
	
};
```



### 試したこと
循環参照になっていると思い、下記２パターンを実施。両方コンパイルエラー

pragma onceを記載
----->C2065	'b': 定義されていない識別子です。

ifndefによるインクルードガード
----->C1014インクルードファイルが多すぎます：深さ=1024


### 補足情報（FW/ツールのバージョンなど）
利用環境：VisualStudio community 2019

【C++】別cppファイルに記載したクラス同士でインスタンスを持ち合いたい

kotlinでは、なぜメソッド<クラス>のように書くのですか？
以下の①と②では何がちがいますか？

①　val toolbar = findViewById<Toolbar>(R.id.toolbar) 
②　val toolbar: Toolbar = findViewById(R.id.toolbar)

なぜkotlinではメソッド<クラス>のように書くのですか？

```ここに言語を入力
コード
`#include <stdio.h>
#include <stdlib.h>

/* 木の節の定義 */
typedef struct node{
	int data;           /* 探索のキーになるデータ型 */
	struct node *left;  /* 左の子 */
	struct node *right; /* 右の子 */
}NODE;
/* メンバright,leftにNULLポインタがセットされているときは該当する子がいないことを表す */

/* 初期状態では二分探索木は空の状態。
   グローバル変数rootが二分探索木の根へのポインタを保持しているものとする */
/* グローバル変数rootをNULLで初期化 */
NODE *root = NULL;

/* エラーメッセージをプリントしてexitする関数*/
/* ポインタ(アドレス)の先のデータを読み取り専用にする */
void   fatal_error(const char *s)
{
	/*  fprintf関数を使ってstderrで標準エラーを出力する*/
    fprintf(stderr,"%s", s); 
    exit(1);  /* 異常終了 */
}

/* 二分探索木から最小の要素を削除する関数 */
/* 削除した節へのポインタを返す
   p:二分探索木へのポインタへのポインタ
     (つまり＊pが木へのポインタとなる) 
    NODE型へのポインターが戻り値 */
NODE *deletemin(NODE **p)
{
	NODE *x;
	
	while ((*p)->left != NULL)
		p=&(*p)->left;
		x=*p;
		*p=(*p)->right;
		return x;
}

/* 二分探索木を探索する関数 */
/* パラメータkeyを受け取ってポインタを返す関数として定義
   key：探索すべきキーの値
   探索に成功した場合そのデータの節へのポインタを返す
   NODE型へのポインターが戻り値 */
NODE *search(int key)
{
	NODE *p;     /* 現在注目している節 */                    
	p=root;      /* まず根に注目する */
	
	/* 進むべき子が存在する限り繰り返す */
  while (p != NULL) { 
  	/* キーと注目している節のデータが等しいか比較 */
    if (key == p->data){
        /* もしキーと注目している節のデータとが等しければポインタを関数として返す */
        printf("探索した値の番地です>>%p\n",p);
        return p;
    }else if (key < p->data){
    	/* キーの方が小さければ左部分木に進む */
    	 p = p->left;
    }else{
    	/* キーの方が大きければ右部分木に進む*/
    	 p = p->right;
  }
  /* ループを抜け出たということは見付からなかったというと
     NULL返して失敗したことを知らせる */
  printf("NotExist\n");
  return NULL;
  }
}

/* 二分探索木から要素を追加する関数*/
/* 探索と同じ要領で木を辿り、辿るべき部分木がなければそこに挿入する */
/* 挿入した要素が置かれる節へのポインタを返す 
   すでに要素が登録されているのなら、何もしないでNULLを返す
   key：挿入するデータ
   NODE型へのポインターが戻り値 */
NODE *insert(int key)
{
	NODE **p,*new;
	/* 変数pが変数rootを指すように初期化する */
	p=&root;
	/* 挿入すべき場所が見つかるまで繰り返す */
	while (*p != NULL) {
	/* キーと注目している節のデータが等しいか比較 */
	 if (key == (*p)->data){
	 /* すでに登録されている */
	    printf("AlreadyExsits\n");
	    return NULL;
	 }else if (key < (*p)->data){ 
	 	/* キーの方が小さければ左部分木に進む */
	 	 p =&(*p)->left;
    }else{
        /* キーの方が大きければ右部分木に進む */
    	 p =&(*p)->right;
	 }
	}
	 /* 挿入されるべき場所が見つかったら */
	 /* 挿入される節をつくる */
	 
	 /* strct型のメモリを確保した分だけnewに入れる。もしNULLだったらエラー */
	 if((new=malloc(sizeof(NODE)))==NULL)
	 fatal_error("out of memory!!");
	 /* 新しい節には子がないのでNULLにしておく */
	 new->left =NULL;
	 new->right=NULL;
	 /* 要素の値をセットする */
	 new->data=key;
	 /* 正しい場所に挿入する */
	 /* ポインタpは挿入される節へのポインタが入っている場所を指している */
	 *p=new;
	 return new;
}

/* 二分探索木から要素を削除する関数 */
/* 削除に成功したら1、要素が存在しなければ0を返す
    key：削除するデータ */
int delete(int key)
{
	/* 親へのポインタを使う */
    NODE **p, *x;
    /* 変数pが変数rootを指すように初期化する */
    p = &root;
    /* 削除対象となる要素を探す */
    while (*p != NULL) {
        /* 見つかった
           変数pは削除される節の親のメンバleft,right
           変数xは削除される節そのものを指している */
        if (key == (*p)->data) {
            x = *p;
            /* 1つも子を持っていない、葉である場合 */
            if (x->left == NULL && x->right == NULL){ 
               *p = NULL;
            /* 右の子のみをもつ */
            }else if (x->left == NULL){
                *p = x->right;
                    /* 左の子のみをもつ */
            }else if (x->right == NULL){
                    *p = x->left;
                    /* 左右2つの子を持つ */
            }else{
                /* 部分木から最小の要素を取り去る */
                *p = deletemin(&x->right);
                (*p)->right = x->right;
                (*p)->left = x->left;
           }
            /* 取り除いた節を解放させる */
            free(x);
            printf("Done\n");
            return 1;

       }else if (key < (*p)->data){
           /* 左部分木に進む */
           p = &(*p)->left;
       }else{
           /* 右部分木に進む */
           p = &(*p)->right;
        }
    }
    /* 削除対象が見つからなかった */
    printf("NotExist\n");
    return 0;
}

/* 二分木を行きがけ順でなぞる */
void preorder(NODE *p)
{
	/* 木が空なら何もしない */
	if(p==NULL)
	return;
	else{
		printf("%d  ",p->data); /* 自身の値を出力 */
		preorder(p->left);    /* 左ノードへ移動 */
		preorder(p->right);   /* 右ノードへ移動 */
	}
	
}

/* 二分木を通りがけ順でなぞる */
/* 全要素を昇順に表示する関数
   二分探索木の全要素を小→大の順で表示する */
/* 全体の流れ
   ある要素の左枝先を全部調べ終えたら、自身の値を出力し、
   次にその要素の右枝先の要素を全部調べる
   左枝を調べる
   調べ終えたら戻ってくる
   値を出力する
   右枝を調べる
   調べ終えたら戻ってくる
   関数を終了して、自身を呼び出した関数の元へと戻る */
void inorder(NODE *p)
{
	/* 木が空なら何もしない */
	if(p==NULL)
	return;
	else{
		/* 引数に左へのポインタを渡すことで、再帰を繰り返して延々と左枝へ移動し
		  一番左、一番小さい値にたどり着く
		  子ノードはないため、引数の値はNULLに当たって戻ってくる
		  一番下位の要素なので、左枝と同様に右枝もない。
          なので終点である NULL に行き当たり、また return で戻ってくる。
          そして「一番左を操作する関数」は処理を終える。
          この関数に戻り値はない。「画面に出力」して、それで終了*/
		inorder(p->left);      /* 左ノードへ移動 */
		printf("%d  ",p->data);  /* 自身の値を出力 */
		inorder(p->right);     /* 右ノードへ移動 */
	}
	/* 関数を終了して、自身を呼び出した関数のもとへ戻る */
	
}

/* 二分木を帰りがけ順でなぞる */
void postorder(NODE *p)
{
	/* 木が空なら何もしない */
	if(p==NULL)
	return;
	else{
	postorder(p->left);   /* 左ノードへ移動 */
	postorder(p->right);  /* 右ノードへ移動 */
	printf("%d  ",p->data); /* 自身の値を出力 */
	}
	
}

int main(void)
{     
	int a,key; 
	int mn=0;
	
	printf("二分探索木をします\n");
	do{
		printf("\nメニューを選んでください\n1=追加   2=行きがけ順  3=通りがけ順  4=帰りがけ順  5=指定した値の番地  6=削除  9=終了\n");
		scanf("%d",&mn);
   switch(mn){
   	
   	case 1:
   	printf("追加する数字を入力してください\n");
   	scanf("%d",&a);
   	insert(a);
	break;
	
    case 2:
    printf("行きがけ順です\n");
	preorder(root);
	 break;
	 
	case 3:
    printf("通りがけ順です\n");
	inorder(root);
	 break;
	
	case 4:
    printf("帰りがけ順です\n");
	postorder(root);
	 break;
	
	case 5:
	printf("指定した値の番地を出力します\n");
	scanf("%d",&key);
    search(key);
    break;
    
    case 6:
	printf("指定した値を削除します\n");
	scanf("%d",&key);
    delete(key);
    break;
    
	case 9:
	printf("終了します\n");
	break;
	
	default:
	printf("エラー：メニューの中の数字を入力してください\n");
   }
	}while (mn !=9);
   return 0;
}
``
```### 前提・実現したいこと``````
二分探索木のプログラムを実装したいです
仕様は 
数字を入力して
1=追加 
2=行きがけ順で表示 
3=通りがけ順で表示 
4=帰りがけ順で表示 
5=指定した値の番地で表示 
6=削除 
9=終了 
ができるようにしたいです 
アドバイスお願いいたします！！

### 発生している問題・エラーメッセージ

「34行目」で記述エラーを発見しました。
「identifier」を付け忘れています。
と出てしまいます
```

### 該当のソースコード
``````ここに言語を入力
ここに言語を入力
```
コード
```




### 悩んでいること
① まず、
NODE *search(int key)
教科書に書いてあったこの宣言の仕方がよく分かりません

型名なしの関数の宣言の仕方を調べると一つだけ解説しているサイトが見つかり、自動的にint型になると書　　いてあったのですが正しいのでしょうか？

 引数があり、戻り値がある場合はvoid型ではない、
 引数があり、戻り値がない場合はvoid型、
 引数がなし、戻り値がある場合もvoid型、
 引数がなし、戻り値がない場合もvoid型
と学びました

preorder(NODE *p)
 postorder(NODE *p)
 inorder(NODE *p)
これらの関数は引数があり、戻り値がない場合なのでvoid型、

int delete(int key)
この関数も引数があり、戻り値がない場合なのでvoid型だと思われるのですがなぜint型なのでしょうか

NODE *search(int key)
 NODE *insert(int key)
 NODE *deletemin(NODE **p)
これらの関数は引数があり、戻り値がある場合はvoid型ではない、int型だと思います。

②keyの扱い方についてです

if (key == p->data)
ここの部分で教科書では関数を使って比べていましたがむずかしいので不等号を使って比べることにしました
keyは値ですが、p->dataは番地ですよね
同じように値同士で扱うにはどのようにしたら良いのでしょうか
構造体の場合、アロー演算子は番地、ドットが実体だと習いましたがエラーが出てしまいます


③関数の値渡しについてです
case 1:
printf("追加する数字を入力してください\n");
scanf("%d",&a);
insert(a);
break;
 case 5:
printf("指定した値の番地を出力します\n");
scanf("%d",&key1);
search(key1);
break;

case 6:
printf("指定した値を削除します\n");
scanf("%d",&key2);
delete(key2);
break;

ここの部分で出力する場合の値と指定した値の変数名はそれぞれ変えたほうが良いですよね？

④探索した値の番地を出力する際に、

/* もしキーと注目している節のデータとが等しければポインタを関数として返す */
printf("探索した値の番地です>>%d\n",p->data);
return p;

としていますが、めちゃくちゃな状態です
探索した値の番地を返す場合、 return pはどのように扱えば良いのか悩みます。





### 補足情報（FW/ツールのバージョンなど

初心者で使い方がよく分かっていません
自分の理解が正しいのか不安なのでコメント多いです
見づらければ修正します
ご指摘ください

c言語で二分探索木を実装したいです

AWSには各種のマネージドサービスがありますが、それぞれのサービス自体がSSL接続を提供していて、サービス間でもSSL通信できるようになっている、という例もよくあります。

そして、AWSのRDBMSサービスであるRDSにもSSL接続が用意されている…のはいいのですが、なぜかRoot CAが独自のものになっています（[公式の説明](https://docs.aws.amazon.com/ja_jp/AmazonRDS/latest/UserGuide/UsingWithRDS.SSL.html)）。

AWS自体はACMでHTTPS向けの証明書も出せるように、CAとしての認可も取れていますし、ElastiCacheなど内部向けの他のマネージドサービスではOS標準のルート証明書で処理ができるような証明書が入っています。

なぜRDSだけ、著名なルート証明書にチェーンがつながる形を取らず、別にルート証明書を用意しないといけない形となっているのでしょうか？