はじめに

C++のイテレータは、配列や vector、map などのコンテナの要素を順番に処理するために使用されます。本記事では、イテレータの基本的な操作方法や応用的な使い方を詳しく解説していきます。

イテレータとは？

イテレータは、C++のコンテナ（vector, map, set など）内の要素にアクセスするためのポインタのようなオブジェクトです。

イテレータの基本

基本的なイテレータの使い方

#include <bits/stdc++.h>
using namespace std;
int main() {
  vector<int> a = {3, 1, 5, 6, 7, 2, 4};
  auto itr1 = a.begin();  // 先頭要素を指す
  itr1 = itr1 + 2;        // 3番目の要素 (a[2]) を指す
  auto itr2 = itr1 + 4;   // 7番目の要素 (a[6]) を指す
  cout << *itr1 << endl;  // 5
  cout << *itr2 << endl;  // 4
}

出力結果

5
4

イテレータを使ったループ処理

イテレータを使って vector の要素を順番に出力する方法を見てみましょう。

#include <bits/stdc++.h>
using namespace std;
int main() {
  vector<int> a = {1, 2, 3};
  for (auto it = a.begin(); it != a.end(); it++) {
    cout << *it << endl;
  }
}

出力結果

1
2
3

イテレータの各種操作

イテレータの移動

advance(イテレータ, k);  // k 個進める
prev(イテレータ, k);     // k 個前のイテレータを取得
next(イテレータ, k);     // k 個先のイテレータを取得

イテレータの指す要素のメンバにアクセス

#include <bits/stdc++.h>
using namespace std;
int main() {
  vector<pair<int, int>> a = {{1, 4}, {2, 5}, {3, 6}};
  auto itr = a.begin() + 1;
  cout << itr->first << ", " << itr->second << endl;
}

出力結果

2, 5

イテレータの指す要素の削除

イテレータを使用して vector の特定の要素を削除することもできます。

コンテナ.erase(イテレータ);

注意点

まとめ

C++のイテレータを活用して、より効率的で柔軟なプログラムを書いてみましょう！

The post イテレータの基本と活用方法を徹底解説！ first appeared on AichiLog.

はじめに

C++の「構造体（struct）」は、複数の異なるデータ型をまとめて扱うための便利な機能です。本記事では、構造体の基本からメンバ関数、コンストラクタまでを詳しく解説し、実践的なサンプルコードを交えて学習します。

構造体とは？

構造体を使うことで、複数のデータ型を1つの新しい型としてまとめることができます。

構造体の基本構文

struct 構造体名 {
  型1 メンバ変数名1;
  型2 メンバ変数名2;
  型3 メンバ変数名3;
  // 必要なメンバ変数を追加
};  // ← セミコロンが必要

例：異なる型をまとめる

#include <bits/stdc++.h>
using namespace std;
struct MyPair {
  int x;     // 整数型のデータ
  string y;  // 文字列型のデータ
};
int main() {
  MyPair p = {12345, "hello"};  // MyPair型のオブジェクトを宣言
  cout << "p.x = " << p.x << endl;
  cout << "p.y = " << p.y << endl;
}

出力結果

p.x = 12345
p.y = hello

メンバ関数

構造体に「メンバ関数」を追加すると、構造体に関連する処理をカプセル化できます。

メンバ関数の定義

struct MyPair {
  int x;
  string y;
  // メンバ関数
  void print() {
    cout << "x = " << x << endl;
    cout << "y = " << y << endl;
  }
};

メンバ関数の使用

int main() {
  MyPair p = {12345, "Hello"};
  p.print();  // メンバ関数の呼び出し
  MyPair q = {67890, "APG4b"};
  q.print();  // 別のオブジェクトでメンバ関数を呼び出し
}

出力結果

x = 12345
y = Hello
x = 67890
y = APG4b

コンストラクタ

構造体のオブジェクトが作成されるときに、自動的に実行される特別な関数を「コンストラクタ」といいます。

コンストラクタの基本形

struct 構造体名 {
  // コンストラクタ
  構造体名() {
    // 初期化処理
  }
};

コンストラクタの使用例

#include <bits/stdc++.h>
using namespace std;
struct MyPair {
  int x;
  string y;
// コンストラクタ
  MyPair() {
    cout << "constructor called" << endl;
  }
};
int main() {
  MyPair p;  // オブジェクト生成時にコンストラクタが呼ばれる
  p.x = 12345;
  p.y = "hello";
  cout << "p.x = " << p.x << endl;
  cout << "p.y = " << p.y << endl;
}

出力結果

constructor called
p.x = 12345
p.y = hello

引数を持つコンストラクタ

コンストラクタに引数を渡すことで、オブジェクトの初期化をより柔軟に行えます。

#include <bits/stdc++.h>
using namespace std;
struct NumString {
  int length;
  string s;
// コンストラクタ
  NumString(int num) {
    cout << "constructor called" << endl;
    s = to_string(num);  // 数値を文字列に変換
    length = s.size();
  }
};
int main() {
  NumString num(12345);  // 12345を渡す
  cout << "num.s = " << num.s << endl;
  cout << "num.length = " << num.length << endl;
}

出力結果

constructor called
num.s = 12345
num.length = 5

まとめ

構造体を活用して、より効率的で分かりやすいC++のプログラムを書いてみましょう！

The post 構造体の基本とコンストラクタの使い方を徹底解説！ first appeared on AichiLog.

はじめに

C++の「参照」は、変数を効率的に扱うために非常に便利な機能です。本記事では、参照の基本的な使い方から、関数への参照渡し、パフォーマンス向上のためのテクニックまでを解説します。

参照とは？

参照（Reference）は、既存の変数に別名をつける仕組みです。ポインタと異なり、NULL（ヌル）を指すことがなく、より直感的に扱うことができます。

参照の宣言と使用方法

#include <iostream>
using namespace std;
int main() {
  int a = 3;
  int &b = a;  // bは変数aの参照
cout << "a: " << a << endl;  // aの値を出力（3）
  cout << "b: " << b << endl;  // bの参照先の値を出力（3）
b = 4;  // 参照先の値を変更（aが4になる）
  cout << "a: " << a << endl;  // aの値を出力（4）
  cout << "b: " << b << endl;  // bの参照先の値を出力（4）
}

参照の特徴

関数への参照渡し

参照渡しとは？

関数の引数を参照として受け取ることで、コピーを作成せずに値を変更することができます。

int g(int &x) {
  x = x * 2;  // xの参照先（呼び出し元の変数）が変更される
  return x;
}
int main() {
  int a = 3;
  int b = g(a);  // xの参照先がaになる
  cout << "a: " << a << endl;  // a: 6
  cout << "b: " << b << endl;  // b: 6
}

参照渡しのメリット

関数で複数の値を返す

参照を使うことで、関数の戻り値とは別に複数の値を返すことができます。

#include <iostream>
using namespace std;
void min_and_max(int a, int b, int c, int &minimum, int &maximum) {
  minimum = min(a, min(b, c));
  maximum = max(a, max(b, c));
}
int main() {
  int minimum, maximum;
  min_and_max(3, 1, 5, minimum, maximum);
  cout << "minimum: " << minimum << endl;  // 1
  cout << "maximum: " << maximum << endl;  // 5
}

参照を使ったパフォーマンス改善

関数の引数を参照渡しにすることで、不要なコピーを減らし、処理速度を大幅に向上できます。

参照を使わない場合（時間がかかる）

#include <vector>
using namespace std;
int sum100(vector<int> a) {  // 配列をコピー
  int result = 0;
  for (int i = 0; i < 100; i++) {
    result += a.at(i);
  }
  return result;
}
int main() {
  vector<int> vec(10000000, 1);
  for (int i = 0; i < 500; i++) {
    cout << sum100(vec) << endl;  // 毎回コピーが発生（遅い）
  }
}

この場合、vec が毎回コピーされるため、処理時間が 7813 ms ほどかかります。

参照を使った場合（高速）

int sum100(const vector<int> &a) {  // 参照渡し（コピーなし）
  int result = 0;
  for (int i = 0; i < 100; i++) {
    result += a.at(i);
  }
  return result;
}

これにより、処理時間が 15 ms まで短縮されます。大量のデータを扱う場合、参照渡しを活用することで大幅なパフォーマンス改善が可能です。

まとめ

C++を効率よく使いこなすために、ぜひ参照を活用してください！

The post 参照の基本と参照渡しを活用する方法 first appeared on AichiLog.

はじめに

C++のポインタは、メモリ管理を理解し、効率的なプログラムを書く上で非常に重要な概念です。本記事では、ポインタの基本からスマートポインタまでを詳しく解説し、実践的なサンプルコードを通じて理解を深めます。

メモリとアドレスの基礎

メモリとは？

メモリは、プログラムが実行される際にデータを保存する領域です。メモリは巨大な配列のようなもので、各要素には一意のアドレス（メモリの位置）が割り当てられます。

変数とメモリの関係

C++では、変数を宣言すると、その変数に対応するメモリ領域が確保されます。例えば、

int a = 10;

このとき、変数 a に対応するメモリ領域が確保され、そのアドレスを調べるには & 演算子を使用します。

cout << &a << endl; // 変数aのアドレスを表示

sizeof 演算子で型のサイズを確認

メモリ上で各データ型がどれくらいのサイズを持つかを sizeof 演算子で調べることができます。

cout << sizeof(int32_t) << endl; // 4
cout << sizeof(int8_t) << endl;  // 1

これは、整数型 int32_t が 4 バイト、int8_t が 1 バイトであることを示しています。

ポインタとは？

ポインタの基本概念

ポインタとは、変数のメモリアドレスを保持する特殊な変数です。ポインタ型の変数を使うことで、メモリ操作を直接行うことができます。

ポインタの宣言と使用方法

int a = 42;
int *p = &a; // 変数aのアドレスをポインタpに格納
cout << *p << endl; // ポインタを使ってaの値を取得（42）

メモリ領域の種類

C++のメモリは、以下の3つの領域に分かれます。

静的領域（Static Area）

スタック領域（Stack Area）

ヒープ領域（Heap Area）

ヒープ領域の確保と解放

ヒープ領域の確保

int *p = new int; // 1つのint型の領域を確保
*p = 100;
cout << *p << endl; // 100

ヒープ領域の解放

delete p; // 確保したメモリを解放

配列の確保と解放

int *arr = new int[10]; // 10個分のメモリ確保
for (int i = 0; i < 10; i++) arr[i] = i;
delete[] arr; // 配列用のdelete[]

スマートポインタとは？

手動の delete は危険！

手動で delete を忘れるとメモリリークが発生し、プログラムの動作が不安定になります。

スマートポインタのメリット

C++11以降では、std::unique_ptr や std::shared_ptr を使うことで、delete の必要がなくなり、安全にメモリ管理ができます。

std::unique_ptr の使い方

基本の使用方法

#include <memory>
int main() {
    std::unique_ptr<int> p1 = std::make_unique<int>(123);
    cout << *p1 << endl; // 123
}

所有権の移動（move）

std::unique_ptr<int> p2;
p2 = std::move(p1); // p1 から p2 に所有権を移動

std::shared_ptr の使い方

複数のポインタで共有

#include <memory>
int main() {
    std::shared_ptr<int> p1 = std::make_shared<int>(123);
    std::shared_ptr<int> p2 = p1; // 共有
    cout << *p1 << endl; // 123
    cout << *p2 << endl; // 123
}

まとめ

よくある質問（FAQ）

Q1. ポインタと参照の違いは？

参照 (int& ref = a;) はエイリアスで、NULL にはできません。ポインタは nullptr にでき、後から指す先を変更できます。

Q2. std::weak_ptr はどんな時に使う？

std::shared_ptr で循環参照を防ぐために使います。

ポインタを正しく使うことで、C++のメモリ管理を自在に扱えるようになります。ぜひ実践してみてください！

The post C++のポインタとスマートポインタの使い方を徹底解説！ first appeared on AichiLog.

1. はじめに

C++のテンプレートは、関数やクラスを汎用的に扱うための機能です。型を一般化することで、コードの再利用性を向上させることができます。

本記事では、C++のテンプレートの基本から実践的な使い方までを詳しく解説します。

2. 関数テンプレートとは？

通常の関数との違い

通常の関数では、異なる型に対して同じロジックを適用する場合、それぞれの型ごとに関数を定義する必要があります。

#include <bits/stdc++.h>
using namespace std;
// int型の二乗を計算する関数
int square_int(int x) {
  return x * x;
}
// double型の二乗を計算する関数
double square_double(double x) {
  return x * x;
}
int main() {
  int a = 3;
  double b = 1.2;
  cout << square_int(a) << endl;
  cout << square_double(b) << endl;
}

この方法では、型ごとに関数を定義しなければならず、冗長になってしまいます。

関数テンプレートの基本構文

テンプレートを使うことで、異なる型でも共通のロジックを持つ関数を一つにまとめることができます。

#include <bits/stdc++.h>
using namespace std;
// 関数テンプレート
template <typename T>
T square(T x) {
  return x * x;
}
int main() {
  int a = 3;
  double b = 1.2;
  cout << square<int>(a) << endl;   // int版のsquare関数
  cout << square<double>(b) << endl; // double版のsquare関数
}

関数テンプレートの使い方

関数テンプレートの呼び出し時には、<T>の部分を指定することで特定の型を適用できます。

関数名<テンプレート引数>(引数1, 引数2, ...);

C++のコンパイラは型推論も行うため、明示的に <int> などを指定しなくても動作する場合があります。

3. クラステンプレートとは？

クラステンプレートの基本構文

クラステンプレートを使うと、異なる型を扱う構造体やクラスを共通のテンプレートとして定義できます。

#include <bits/stdc++.h>
using namespace std;
// クラステンプレートの宣言
template <typename T>
struct Point {
  T x;
  T y;
  void print() {
    cout << "(" << x << ", " << y << ")" << endl;
  }
};
int main() {
  // int型のPoint構造体
  Point<int> p1 = {0, 1};
  p1.print();
  // double型のPoint構造体
  Point<double> p2 = {2.3, 4.5};
  p2.print();
}

クラステンプレートの使い方

構造体名<テンプレート引数>

クラステンプレートを使うことで、異なる型に対して同じロジックを適用することができます。

4. 定数のテンプレート

C++では、定数にもテンプレートを適用できます。

定数テンプレートの基本構文

template <typename T>
const T 定数名 = 値;

例：タプルの要素を交換する関数

以下のコードは、テンプレートを利用してタプルの特定の要素を交換する関数を実装しています。

#include <bits/stdc++.h>
using namespace std;
// タプルのINDEX1番目とINDEX2番目を交換する関数
template <int INDEX1, int INDEX2>
void tuple_swap(tuple<int, int, int> &x) {
  swap(get<INDEX1>(x), get<INDEX2>(x));
}
int main() {
  tuple<int, int, int> x = make_tuple(1, 2, 3);
tuple_swap<0, 2>(x);  // 1番目と3番目を交換
  cout << get<0>(x) << ", " << get<1>(x) << ", " << get<2>(x) << endl;
  tuple_swap<0, 1>(x);  // 1番目と2番目を交換
  cout << get<0>(x) << ", " << get<1>(x) << ", " << get<2>(x) << endl;
}

5. まとめ

C++のテンプレートを活用することで、型に依存しない汎用的なコードを記述できるようになります。

本記事のポイント

テンプレートの概念を理解し、実際の開発に活かしてみてください！

The post C++のテンプレート完全ガイド：関数テンプレート・クラステンプレート・定数テンプレートを徹底解説 first appeared on AichiLog.

本記事では、STLの主要なコンテナについて、その特徴や基本操作、実践的なサンプルコードとともに解説していきます。

1. STLのコンテナの種類

STLのコンテナは大きく分けて3つのカテゴリーに分類されます。

シーケンスコンテナ（Sequence Containers）

データを順番に格納するコンテナ。

連想コンテナ（Associative Containers）

キーと値のペアを管理するコンテナ。

無順序連想コンテナ（Unordered Associative Containers）

ハッシュテーブルを使用した連想コンテナ。

2. map（連想配列）

mapの基本操作

map はキーと値のペアを管理する連想配列であり、辞書のようなデータ構造です。

#include <bits/stdc++.h>
using namespace std;
int main() {
  map<string, int> score;
  score["Alice"] = 100;
  score["Bob"] = 89;
  score["Charlie"] = 95;
  cout << score.at("Alice") << endl;
  cout << score.at("Bob") << endl;
  cout << score.at("Charlie") << endl;
}

操作一覧

3. queue（待ち行列）

queue は先入れ先出し（FIFO）のデータ構造です。

#include <bits/stdc++.h>
using namespace std;
int main() {
  queue<int> q;
  q.push(10);
  q.push(3);
  q.push(6);
  q.push(1);
  while (!q.empty()) {
    cout << q.front() << endl;
    q.pop();
  }
}

操作一覧

4. priority_queue（優先度付きキュー）

priority_queue は最大値（または最小値）を素早く取得できるデータ構造です。

#include <bits/stdc++.h>
using namespace std;
int main() {
  priority_queue<int> pq;
  pq.push(10);
  pq.push(3);
  pq.push(6);
  pq.push(1);
  while (!pq.empty()) {
    cout << pq.top() << endl;
    pq.pop();
  }
}

小さい順に取り出す priority_queue

priority_queue<int, vector<int>, greater<int>> pq;

5. set（集合）

set は重複のないデータの集合を扱うコンテナです。

#include <bits/stdc++.h>
using namespace std;
int main() {
  set<int> S;
  S.insert(3);
  S.insert(7);
  S.insert(8);
  S.insert(10);
  S.insert(3);
  cout << "size: " << S.size() << endl;
  if (S.count(7)) cout << "found 7" << endl;
}

6. stack（スタック）

stack は後入れ先出し（LIFO）のデータ構造です。

#include <bits/stdc++.h>
using namespace std;
int main() {
  stack<int> s;
  s.push(10);
  s.push(1);
  s.push(3);
  cout << s.top() << endl;
  s.pop();
  cout << s.top() << endl;
}

7. lower_bound / upper_bound

二分探索を利用してソート済み配列内の要素を検索します。

#include <bits/stdc++.h>
using namespace std;
int main() {
  vector<int> a = {0, 10, 13, 14, 20};
  cout << *lower_bound(a.begin(), a.end(), 12) << endl;
  cout << *upper_bound(a.begin(), a.end(), 10) << endl;
}

8. まとめ

STLのコンテナは、適切なデータ構造を選択することで、より効率的なプログラムを書くことができます。各コンテナの特性を理解し、適材適所で活用しましょう！

The post STLのコンテナとは？基本解説と実践的な使い方 first appeared on AichiLog.

はじめに

C++にはSTL（Standard Template Library）と呼ばれる標準ライブラリが用意されており、これを活用することでプログラムの可読性と効率性を向上させることができます。本記事では、STLに含まれる便利な関数 min, max, swap, sort, reverse を解説し、それぞれの使い方や注意点を紹介します。

min関数で最小値を取得

min関数の基本的な使い方

min 関数は、2つの値を比較し、そのうち小さい方の値を返します。使用するには <algorithm> ヘッダをインクルードする必要があります。

#include <iostream>
#include <algorithm>
using namespace std;
int main() {
    int answer = min(3, 5);
    cout << answer << endl; // 3
}

この例では min(3, 5) により 3 が返され、出力されます。

型の違いによるエラーの注意点

min 関数は、同じ型の値 を比較する必要があります。異なる型を比較しようとすると、コンパイルエラーが発生します。

int main() {
    double answer = min(2.12, 5); // エラー！
    cout << answer << endl;
}

このコードは 2.12（double型）と 5（int型）を比較しようとするため、型の不一致によりコンパイルエラーが発生します。エラーを避けるには、型を統一する必要があります。

int main() {
    double answer = min(2.12, 5.34); // OK
    cout << answer << endl; // 2.12
}

max関数で最大値を取得

max関数の基本的な使い方

max 関数は min 関数と同様に、2つの値を比較して大きい方の値を返します。

#include <iostream>
#include <algorithm>
using namespace std;
int main() {
    int answer = max(3, 5);
    cout << answer << endl; // 5
}

この例では max(3, 5) により 5 が返され、出力されます。min 関数と同じく、比較する値の型を統一する必要がある点に注意してください。

swap関数で値を入れ替える

2つの変数の値を交換する方法

swap 関数を使うことで、2つの変数の値を簡単に入れ替えることができます。

#include <iostream>
#include <algorithm>
using namespace std;
int main() {
    int a = 3;
    int b = 5;
    swap(a, b);
    cout << a << endl; // 5
    cout << b << endl; // 3
}

このコードでは、swap(a, b) によって a と b の値が入れ替わり、a は 5、b は 3 となります。

sort関数とreverse関数で配列を操作する

sort関数で昇順ソート

sort 関数を使用すると、配列やベクターを昇順（小さい順）に並び替えることができます。

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main() {
    vector<int> vec = {2, 5, 2, 1};
    sort(vec.begin(), vec.end()); // {1, 2, 2, 5}
    for (int i = 0; i < vec.size(); i++) {
        cout << vec.at(i) << " ";
    }
    cout << endl;
}

reverse関数で降順ソート

reverse 関数を使うと、要素の順番を反転させることができます。sort 関数と組み合わせることで降順（大きい順）に並び替えることが可能です。

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main() {
    vector<int> vec = {2, 5, 2, 1};
    sort(vec.begin(), vec.end()); // {1, 2, 2, 5}
    reverse(vec.begin(), vec.end()); // {5, 2, 2, 1}
    for (int i = 0; i < vec.size(); i++) {
        cout << vec.at(i) << " ";
    }
    cout << endl;
}

STL関数の応用と注意点

STL関数の組み合わせ

STLの関数は単体で使うだけでなく、複数を組み合わせて効率的にデータを処理することができます。

例えば、min と max を使ってベクター内の最小値と最大値を取得することが可能です。

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main() {
    vector<int> vec = {3, 1, 4, 1, 5, 9};
    int min_val = *min_element(vec.begin(), vec.end());
    int max_val = *max_element(vec.begin(), vec.end());
    cout << "Min: " << min_val << endl;
    cout << "Max: " << max_val << endl;
}

型の扱いに注意

STLの関数を使用する際には、比較するデータ型を統一することが重要です。異なる型を比較するとコンパイルエラーの原因になります。

—

これらの関数を適切に使うことで、より効率的で可読性の高いC++プログラムを作成することができます。

The post C++の標準ライブラリ（STL）を活用した便利な関数解説 first appeared on AichiLog.

1. C++の基本的なヘッダファイル

iostream ヘッダ

C++でプログラムを書く際、最も基本的なヘッダファイルの一つが iostream です。

#include <iostream>

このヘッダファイルには以下の機能が含まれています：

• cout：標準出力
• endl：改行
• その他の入出力関連の機能

bits/stdc++.h について

競技プログラミングでよく見かける以下のインクルード文について説明します：

#include <bits/stdc++.h>

これは全てのヘッダファイルをインクルードする便利な方法ですが、以下の理由から実務では非推奨です：

• ビルド時間の増加
• メモリ使用量の増加
• 依存関係の不透明化

2. 名前空間（namespace）の使用

C++では名前の衝突を避けるために名前空間を使用します。標準ライブラリの機能は std 名前空間に属しています。

#include <iostream>
using namespace std;  // std名前空間を使用
int main() {
    cout << "Hello, World!" << endl;  // std::を省略可能
    return 0;
}

3. コンパイルと実行

基本的なコンパイルコマンド

g++ main.cpp -o main && ./main

このコマンドの内訳：

• g++：C++コンパイラ
• main.cpp：ソースファイル
• -o main：出力ファイル名の指定
• &&：コマンドの連結
• ./main：実行

代替的な実行方法

g++ main.cpp && ./a.out

または

g++ main.cpp -o main
./main

4. コンパイルとビルドの違い

コンパイル

• ソースコードを機械語に変換する工程
• 例：g++ main.cpp

ビルド

• コンパイルとリンクを含む総合的な工程
• 例：g++ main.cpp -o main
• 以下の工程を含むことがある：

• • コンパイル
  • 依存関係の解決
  • リンク
  • テスト
  • デプロイ

5. 他言語との比較

Go 言語（コンパイル言語）

go run main.go

• コンパイルと実行を 1 つのコマンドで実行可能

Python（インタプリタ言語）

python main.py

• コンパイル不要
• 実行時に逐次解釈
• 必要に応じてバイトコードに変換（.pyc ファイル）

まとめ

C++は強力な言語ですが、コンパイル言語としての特性上、実行までの手順が他の言語と比べて複雑です。しかし、この複雑さは実行時のパフォーマンスという形で還元されます。基本的な開発フローを理解することで、より効率的なプログラミングが可能になります。

The post C++のコンパイルと実行の基礎知識 first appeared on AichiLog.