常連

C++を使って組み込みソフトの仕事をしている三十路エンジニアですが、
恥ずかしながら最近になってムーブセマンティクスの勉強をしております。

[こちらのブログ](https://yohhoy.hatenablog.jp/entry/2012/12/15/120839)で理解は進んだのですが、普段仕事で多用している参照渡しとの使い分けが
しっかりと理解できていません。

例えば、vectorの要素を2倍にする関数を`std::move`で次のように書けると思います。
```cpp
#include <vector>
#include <utility>

std::vector<int> twice_vec(std::vector<int> vec) {
  for (auto& e : vec) {
    e *= 2;
  }

  return std::move(vec);
}

int main(void) {
  std::vector<int> a = {1, 2, 3};

  std::vector<int> b = twice_vec(std::move(a));

  return 0;
}
```

シンタックスは明らかに異なるものの、同じ「ような」ことを参照渡しで行うと以下のように書けると思います。
```cpp
#include <vector>

void twice_vec_2(std::vector<int>& vec) {
  for (auto& e: vec) {
    e *= 2;
  }
}

int main(void) {
  std::vector<int> a = {1, 2, 3};

  twice_vec_2(a);

  return 0;
}
```

当方の認識では、パフォーマンス的に参照渡しで書いたコードが劣ることはないと理解しています。
この差は、ムーブで書いたほうが各変数がimmutableなように書いてあって分かりやすい以外に何かあるのでしょうか。
どういう時はどっちのほうが良い、などあるのでしょうか。
（極端な話、今までポインタや参照渡しで書かれていたコードは全てムーブセマンティクスで書いたほうが良いというような話なのでしょうか）

何卒、よろしくお願いいたします。

C++ 参照渡し vs ムーブセマンティクス

### 実現したいこと

- C++の実行コードをヘッダに書くか、ソースに書くかについて、皆さんのご意見をうかがいたい
- 例えば「自分はベストプラクティスを知っているので広めたい！」という意見
- 例えば「自分はこういうケースでいつもこうしている」という意見
- 例えば「自分はよく知らないけど、こういうツールを知っている」という意見
- etc...

### 前提

- C++11(以降)
- 公開範囲については皆さんが想定されるケースを決めてください(言及しない場合はオープンソース)
- 規模感については皆さんが想定されるケースを決めてください(言及しない場合は数k行程度以内)
- 外部コードの有無については、皆さんが想定されるケースを決めてください(言及しない場合は自身がアプリから使用されるライブラリ)
- 処理系についてはgcc9以降限定
- プラットフォームについては限定しませんが、OSはあるものとしてください

### 発生している問題・エラーメッセージ

- (A)ヘッダに書く場合は、公開したくないコードまで公開する必要がある
- (B)ソースに書く場合は、テンプレートのインスタンス化が悩ましい
- (C)ヘッダに書く場合は、同じものが複数展開されるため、それぞれでコードが異なりうる懸念がある

(B),(C)については以下コードで例示します

### 該当のソースコード
環境構築用のスクリプトです。最後にビルドして実行します。
```bash
#!/bin/sh
cat >Makefile <<EOF
CC=g++
CXXFLAGS=-g -std=c++11 -Wall
all: main main_lib main_diff
clean:
        rm -f *.o *.a main main_lib main_diff
main: main.o
main_lib: main_lib.o libsub.a
        \$(CC) main_lib.o -L. -lsub -o main_lib
libsub.a: libsub.a(sub_lib.o)
main_diff: main_diff.o libsub2.a
        \$(CC) main_diff.o -L. -lsub2 -o main_diff
main_diff.o: main_diff.cpp sub_diff_v1.h
        cp sub_diff_v1.h sub_diff.h
        \$(CXX) \$(CXXFLAGS) \$(CPPFLAGS) \$(TARGET_ARCH) -c main_diff.cpp
sub2_diff.o: main_diff.cpp sub_diff_v2.h
        cp sub_diff_v2.h sub_diff.h
        \$(CXX) \$(CXXFLAGS) \$(CPPFLAGS) \$(TARGET_ARCH) -c sub2_diff.cpp
libsub2.a: libsub2.a(sub2_diff.o)
EOF
cat >main.cpp <<EOF
#include <iostream>
#include "sub.h"
int main() {
    Hoge hoge;
    hoge.print(std::cout);
    return 0;
}
EOF
cat >main_diff.cpp <<EOF
#include <iostream>
#include "sub_diff.h"
#include "sub2_diff.h"
int main() {
    Hoge hoge;
    hoge.print(std::cout);
    sub2();
    return 0;
}
EOF
cat >main_lib.cpp <<EOF
#include <iostream>
#include "sub_lib.h"
int main() {
    Hoge hoge;
    hoge.print(std::cout);
    return 0;
}
EOF
cat >sub.h <<EOF
#pragma once
#include <ostream>
struct Hoge {
    template<typename T> void print(T& out) { out << "ほげ" << std::endl; }
};
EOF
cat >sub2_diff.cpp <<EOF
#include <iostream>
#include "sub_diff.h"
#include "sub2_diff.h"
void sub2() {
    Hoge hoge;
    hoge.print(std::cout);
}
EOF
cat >sub2_diff.h <<EOF
#pragma once
void sub2();
EOF
cat >sub_diff.h <<EOF
#pragma once
#include <ostream>
struct Hoge {
    template<typename T> void print(T& out) { out << "ふが" << std::endl; }
};
EOF
cat >sub_diff_v1.h <<EOF
#pragma once
#include <ostream>
struct Hoge {
    template<typename T> void print(T& out) { out << "ほげ" << std::endl; }
};
EOF
cat >sub_diff_v2.h <<EOF
#pragma once
#include <ostream>
struct Hoge {
    template<typename T> void print(T& out) { out << "ふが" << std::endl; }
};
EOF
cat >sub_lib.cpp <<EOF
#include <ostream>
#include "sub_lib.h"
template<typename T>
void Hoge::print(T& out) {
    out << "ほげ" << std::endl;
}
template void Hoge::print(std::ostream&);
EOF
cat >sub_lib.h <<EOF
#pragma once
struct Hoge {
    template<typename T> void print(T& out);
};
EOF
make
./main
./main_lib
./main_diff
```

### (B)/(C)の説明
まずは基本となるmain.cppとsub.hを見てください。

**main.cpp**
```c++
#include <iostream>
#include "sub.h"
int main() {
    Hoge hoge;
    hoge.print(std::cout);
    return 0;
}
```
**sub.h**
```c++
#pragma once
#include <ostream>
struct Hoge {
    template<typename T> void print(T& out) { out << "ほげ" << std::endl; }
};
```
何の変哲もない「ほげ」って出力するだけのコードです。
ヘッダにコードが記述されているので、モジュールも1つだけになっている単純な例です。
自分のコードがsub.hで、これを公開すると思ってください。

#### (B)ソースに書く場合は、テンプレートのインスタンス化が悩ましい

sub.hの実行コードをソースに移し、(静的)ライブラリにする形態がmain_lib.cpp、sub_lib.h、sub_lib.cppになります。

**main_lib.cpp**
```c++
#include <iostream>
#include "sub_lib.h"
int main() {
    Hoge hoge;
    hoge.print(std::cout);
    return 0;
}
```
**sub_lib.h**
```c++
#pragma once
struct Hoge {
    template<typename T> void print(T& out);
};
```
**sub_lib.cpp**
```c++
#include <ostream>
#include "sub_lib.h"
template<typename T>
void Hoge::print(T& out) {
    out << "ほげ" << std::endl;
}
template void Hoge::print(std::ostream&);
```
気づきましたでしょうか？

sub_lib.cppの最終行に、テンプレートのインスタンス化用の定義が入っています。この行はstd::coutのクラスであるstd::ostreamが定義されています。これがないと main_lib.cpp 側の hoge.print(std::cout) 呼び出しでundefined referenceが発生しちゃうわけです。呼び出す側のコードで、T=std::outputstreamなメソッドを必要とするので、呼び出される側のコードでそのインスタンス化が必要になるということです。

つまり呼び出す側のコードで使いたいTが増えるごとに、呼び出される側にこの行が必要になるということになります。これが面倒だというのが(B)です。

#### (C)ヘッダに書く場合は、同じものが複数展開されるため、それぞれでコードが異なりうる懸念がある

説明のため、元のコードを以下のようにしています。
- main.cpp→main_diff.cpp
- sub.h→sub_diff_v1.h
さらに同じものを複数展開するために、
- sub.h→sub_diff_v2.h
- sub2_diff.h
- sub2_diff.cpp
というのを用意しています。ようはモジュールを2つに増やし、それぞれにsub.h相当をインクルードして呼び出させるということです。
sub2側はライブラリにして、main側からリンクします。

**main_diff.cpp**
```c++
#include <iostream>
#include "sub_diff.h"
#include "sub2_diff.h"
int main() {
    Hoge hoge;
    hoge.print(std::cout);
    sub2();
    return 0;
}
```
**sub_diff_v1.h**
```c++
#pragma once
#include <ostream>
struct Hoge {
    template<typename T> void print(T& out) { out << "ほげ" << std::endl; }
};
```
**sub_diff_v2.h**
```c++
#pragma once
#include <ostream>
struct Hoge {
    template<typename T> void print(T& out) { out << "ふが" << std::endl; }
};
```
**sub2_diff.h**
```c++
#pragma once
void sub2();
```
**sub2_diff.cpp**
```c++
#include <iostream>
#include "sub_diff.h"
#include "sub2_diff.h"
void sub2() {
    Hoge hoge;
    hoge.print(std::cout);
}
```
各.cppファイルでインクルードしてるファイルがsub_diff.hになっていますが、これは_v1/_v2というサフィックスがついたファイルをmake注にコピーして作成しています。何を意図しているかというと、main_diff側と、libsub2.a側で異なるバージョンのsub_diff.hを使ったケースの再現です。そのままビルドすると、main_diff側のコードに一本化されて動きますが、最適化させるとインライン展開されてそれぞれ異なるコードで動作します。

### 最後に

C++を使ってる人なら誰もが一度はどうしようかと悩むところだと思いますが、あっちを立てればこっちが立たずみたいな状況なので、意見を集めてみてもいいかなと思って、書いてみました。参考までに私は公開ソースなら全部ヘッダにしていて、非公開なら規模次第でソースにしてます。テンプレートは限定的な使い方にします。

※勘違いの指摘なども歓迎です


C++のコードをヘッダに書くか、ソースに書くかについて

### 実現したいこと／試したこと

最終的に実現したいことを端的に述べますと､ローカル変数を参照する特定の処理を定義だけしておき､あとから実行したいということになります。
そこで､まず､下記のようなソースコードを考えました。
```C++
#include <functional>
#include <iostream>
class Foo {
public:
    std::function<void()> f;
    void func() {
        int i = 1;
        std::cout << "func: " << i << ", " << &i << std::endl;
        f = [=]()->void { // 参照キャプチャ`&`不可：解放済み変数にアクセスしておかしな値が出力される
            std::cout << "lambda: " << i << ", " << &i << std::endl;
        };
        i = 2;
    }
};
int main() {
    Foo foo;
    foo.func();
    foo.f();
    return 0;
}
```
上記プログラムの実行結果は下記のようになります。
```
func: 1, 0x70fd9c
lambda: 1, 0xbf23f0
```
ポイントは､ラムダ式によって出力された変数の値が2ではなく､1であるということです。
このことから､ラムダ式のコピーキャプチャはラムダ式が定義される直前の値がコピーされる仕様であると理解しました。
しかしながら､下記のソースコードを考えたときにわからなくなりました。
```C++
#include <functional>
#include <iostream>
class Foo {
private:
    int i;
public:
    std::function<void()> f;
    void func() {
        i = 1;
        std::cout << "func: " << i << ", " << &i << std::endl;
        f = [=]()->void { // 参照キャプチャ`&`可能
            std::cout << "lambda: " << i << ", " << &i << std::endl;
        };
        i = 2;
    }
};
int main() {
    Foo foo;
    foo.func();
    foo.f();
    return 0;
}
```
変更点は､ローカル変数をメンバ変数に変更しただけです。
しかしながら､上記プログラムの実行結果は下記のようになります。
```
func: 1, 0x70fde0
lambda: 2, 0x70fde0
```
ラムダ式によって出力された変数の値が2になっています。
ラムダ式が定義されたあとに実行した値の変更がなぜか反映されてしまっています。
一体ラムダ式のコピーキャプチャはどのタイミングで実行される仕様なのでしょうか？
そもそも､一番最初のソースコード自体が未定義動作の代物なのでしょうか？
いくつかのコンパイラで試しましたが､動作が一貫していたので､C++の言語仕様に規定されていると考えていたのですが…
言語仕様のこのあたりに記載があるよ等も教えていただけると私の勉強にもなり助かります。
回答よろしくお願いします。

### 補足情報（FW/ツールのバージョンなど）

C++17


ラムダ式のコピーキャプチャの仕様を知りたい

いつもお世話になります。

double型の変数について、0.0であるか否かをチェックする時（例：ゼロ割チェック）
今まで以下のように書いていました。
```cpp
#include <cfloat>
#include <cmath>
double x = 0.0;
bool is_zero = (fabs(x) < DBL_EPSILON);
```

しかしながら、`DBL_MIN`というものも存在し、かつ定義がそれぞれ以下のようになっていることを知りました。

- `DBL_MAX`:1と1以上の最小の数との差を表す
- `DBL_MIN`:正の最小の数を表す
- 一般に `DBL_MIN < DBL_EPSILON` である

## 質問1
`double`型変数がゼロか否かを確認する際（とりあえずゼロ割回避のシーン限定で結構です）、
`DBL_MIN`と`DBL_EPSILON`、どちらを使うべきかの推奨はあるのでしょうか。
```cpp
bool is_zero = (fabs(x) < DBL_EPSILON);  // This or...
bool is_zero = (fabs(x) < DBL_MIN);      // THIS ?
```

## 質問2
`DBL_EPSILON`が「1と1以上の〜」となっていて、「0と0以上の〜」ではない理由が知りたいです。

推測は、以下のように`DBL_EPSILON`に掛け算をして、スケールに応じて使えるようにかな、と思いましたが、
正しいでしょうか。
（意味の定義を0と0以上の~にしてしまうと掛け算する意味がない？）
```cpp
#include <cfloat>
#include <cmath>

double x = 50.000000000000015;
double y = 50.00000000000002;

bool is_same = (fabs(x - y) < (DBL_EPSILON * std::max(x, y)));
```

大変浅学で恐縮です。
よろしくお願い致します。

## 参考リンク
- [DBL_MIN: cpprefjp](https://cpprefjp.github.io/reference/cfloat/dbl_min.html)
- [DBL_EPSILON: cpprefjp](https://cpprefjp.github.io/reference/cfloat/dbl_epsilon.html)

(C++) double型変数が0.0か否かの判定

以下のようなエラー文がでていて原因を調べても解決できていない状態なのでアドバイス頂きたいです。

```error
src/***.cpp: In member function ‘関数名’:
src/***.cpp:26: error: expected initializer before --
make: *** [obj/***.o] Error 1
```

状況としては特定のスレッドの中でクラスを作り、そのクラスのメソッド内で他のクラスを作りそのメソッドを実行しようとしています。そのメソッド内でなにもしないとコンパイルエラーは起こりません。しかしそのメソッドでなにか関数を呼ぶとその関数が -- のところに入った形でコンパイルエラーが起こります。宜しくお願い致します。。。

C++ のexpected initializer before *** のエラーについて

こんにちは。

C++11で対応された範囲ベースfor、すっごく便利なのでよく使っているのですが、たまにインデックス番号も欲しい時があります。
そんな時は、`for (size_t i=0; 云々`で回してます。ドン臭いし、既に範囲ベースforで書いているコードを書き換えるのも面倒です。

begin(), end()で回せばdistance()が使えることは分かっているのですが、`for (size_t i=0; 云々`と同様書き換えが面倒なのです。更にバグでイテレータがend()を越えるとちょっと怖いです。

頭で`size_t index=0;`してループの最後で`++index;`もありですが、`continue`使うとはまりそうです。

範囲ベースforで回している時にインデックス番号をスマートに計算する方法ってないでしょうか？
ありそうな気もするのですが、グーグル先生教えてくれないのです。orz

---
【閑話休題】
なぜに範囲ベースforはiteratorを返さないのでしょう？
[for-range-declaration = *__begin;](http://cpplover.blogspot.jp/2009/08/n2930-range-based-for-loop.html)じゃなくて、`for-range-declaration = __begin;`なら良かったのに。

---
【その後】
その後、調べていて、ランダム・アクセス・イレテータでないコンテナの場合、std:distance()はリストを追跡するらしいことが分かりました。ということは同様にoperator[]も追跡する筈ですね。（何を今更なのですが。）
今はvectorで範囲ベースforを使ってますが一部はforward_listへ変更します。これを見越すと、インデックスを使うためにはイテレータ型のfor文へ変更しインデックスも追加する必要があります。for文がごちゃごちゃになり、範囲ベースforとの落差に悶え死にそうでした。しかも、autoの型が変わってしまうし．．．

個人的にこれらが許せないので、yumetodoさんのリンク先の記事からヒントを得て、ツールを作りました。
考え方は、自作の隠しイテレータをコンパイラへ返して、それがインクリメントされた時にインデックスも一緒にインクリメントするイメージです。
ですので、listでも使えますし、listのイテレータをdistanceした時のような追跡処理も発生しません。そして、autoで推論される型は同じコンテナの要素のままですので、範囲ベースforブロック内の変更も不要です。

```C++
#include <iterator>

// ***************************************************************************
//      範囲ベースforにインデックス機能を追加する
// ***************************************************************************

namespace staff_only
{

//----------------------------------------------------------------------------
//      隠しイテレータ・クラス
//----------------------------------------------------------------------------

template<typename tValueType, typename tParentIterator>
class Iterator
{
    tParentIterator mParentIterator;
    std::size_t&    mIndexReference;
public:
    explicit Iterator(tParentIterator iIterator, std::size_t& iIndexReference) :
        mParentIterator(iIterator),
        mIndexReference(iIndexReference)
    { }

    tValueType& operator*() {return *mParentIterator;}
    tParentIterator& operator++()
    {
        ++mParentIterator;
        ++mIndexReference;
        return mParentIterator;
    }
    bool operator==(Iterator const& rhs) {return mParentIterator==rhs.mParentIterator;}
    bool operator!=(Iterator const& rhs) {return mParentIterator!=rhs.mParentIterator;}
};

//----------------------------------------------------------------------------
//      コンテナ
//----------------------------------------------------------------------------

template<class tContainer>
class Indexer
{
    typedef typename tContainer::value_type ValueType;
    typedef typename tContainer::iterator ParentIterator;
    typedef Iterator<ValueType, ParentIterator> InnerIterator;

    // Indexer実体
    tContainer&     mContainer;
    std::size_t&    mIndexReference;
public:
    explicit Indexer(tContainer& iContainer, std::size_t& iIndexReference) :
        mContainer(iContainer),
        mIndexReference(iIndexReference)
    {
        mIndexReference=0;
    }
    InnerIterator begin()
    {
        return InnerIterator(mContainer.begin(), mIndexReference);
    }
    InnerIterator const end() const
    {
        return InnerIterator(mContainer.end(), mIndexReference);
    }
};

//----------------------------------------------------------------------------
//      生配列
//----------------------------------------------------------------------------

template<class tValueType, size_t tDim>
class Indexer<tValueType[tDim]>
{
    typedef tValueType* ParentIterator;
    typedef Iterator<tValueType, ParentIterator> InnerIterator;

    // Indexer実体
    typedef tValueType Container[tDim];
    Container&      mContainer;
    std::size_t&    mIndexReference;
public:
    explicit Indexer(Container& iContainer, std::size_t& iIndexReference) :
        mContainer(iContainer),
        mIndexReference(iIndexReference)
    {
        mIndexReference=0;
    }
    InnerIterator begin()
    {
        return InnerIterator(&mContainer[0], mIndexReference);
    }
    InnerIterator const end() const
    {
        return InnerIterator(&mContainer[tDim], mIndexReference);
    }
};
}   // namespace staff_only

//----------------------------------------------------------------------------
//      API
//----------------------------------------------------------------------------

template<class tContainer>
staff_only::Indexer<tContainer> getIndexer(tContainer& iContainer, std::size_t& iIndexReference)
{
    return staff_only::Indexer<tContainer>(iContainer, iIndexReference);
}

// ***************************************************************************
//      使い方
// ***************************************************************************

#include <array>
#include <vector>
#include <forward_list>
#include <list>

#include <iostream>

int main()
{
    struct TestClass
    {
        int x, y;
    };
    TestClass                       wRawArray[] = {{5,1}, {4,2}, {3,3}, {2,4}, {1,5}, {0,6}};
    std::array<TestClass, 5>        wArray      ={{{4,2}, {3,3}, {2,4}, {1,5}, {0,6}}};
    std::vector<TestClass>          wVector     = {{3,3}, {2,4}, {1,5}, {0,6}};
    std::forward_list<TestClass>    wForwardList= {{2,4}, {1,5}, {0,6}};
    std::list<TestClass>            wList       = {{1,5}, {0,6}};

    std::size_t wIndex;

    std::cout << "raw-array\n";
    for (auto& wData : getIndexer(wRawArray, wIndex)) {
        std::cout << "[" << wIndex << "]=" << wData.x << ", " << wData.y << "\n";
    }

    std::cout << "\nstd::array\n";
    for (auto& wData : getIndexer(wArray, wIndex)) {
        std::cout << "[" << wIndex << "]=" << wData.x << ", " << wData.y << "\n";
    }

    std::cout << "\nstd::vector\n";
    for (auto& wData : getIndexer(wVector, wIndex)) {
        std::cout << "[" << wIndex << "]=" << wData.x << ", " << wData.y << "\n";
    }

    std::cout << "\nstd::forward_list\n";
    for (auto& wData : getIndexer(wForwardList, wIndex)) {
        std::cout << "[" << wIndex << "]=" << wData.x << ", " << wData.y << "\n";
    }

    std::cout << "\nstd::list\n";
    for (auto& wData : getIndexer(wList, wIndex)) {
        std::cout << "[" << wIndex << "]=" << wData.x << ", " << wData.y << "\n";
    }

    return 0;
}


```

msvc2015とMinGW 5.2.0で動作確認してます。

２点不満が残りました。orz
イテレータはこっそりインクリメントされているので、インデックスもこっそりインクリメントされます。範囲ベースforの仕様とも言えるのでこの点は許容することにしました。
インデックスのスコープがforの外側になってしまいます。内側にしたいのですが、範囲ベースforの構文に割り込めず諦め。

C++ 範囲ベースforの中でインデックス番号を取り出す方法

#質問概要

浮動小数値(float)<->固定小数値の変換を可能にするアルゴリズムがどうしてうまくいくのかがわかりません。後に示すやり方でなぜうまくいくのか、理由をご教授いただきたいです。

#質問詳細
このブロックの前段では、質問をわかりやすくするため状況の説明を実際のコードを用いて行っております。
後段では、何がわからないのかを説明しています。

浮動小数値を固定小数値に変換して保持する場合、一般的に以下のアルゴリズムが使われているようです。
なお、わかりやすさのため、以下のルールに従って変換が行われるものとします
**・**固定小数値の小数部分は下位8bit とする。
**・**固定小数値は int型の変数(fix)に格納する。
**・**浮動小数値は float型の変数(floats) とする。

**浮動小数→固定小数変換アルゴリズム**
```C++
int float_to_fixed(float floats)
{
	int ret;

	ret = (int)(roundf(floats * (1 << 8)));//所与の浮動小数値　☓　2^(固定小数部のbit 数)

	return (ret);
}
``` 
**固定小数→浮動小数変換アルゴリズム**
```C++

float fixed_to_float(int fixed)
{
	float ret;

	ret = ((float)fixed / (float)(1 << 8));//固定少数値をfloatにキャストして、2^(固定小数値の小数部分のbit数)で割る

	return (ret);
}

```

**参考文献** 
1 : https://embeddedartistry.com/blog/2018/07/12/simple-fixed-point-conversion-in-c/
2 : https://medium.com/incredible-coder/converting-fixed-point-to-floating-point-format-and-vice-versa-6cbc0e32544e


上に示した２つの関数について、どうしてこの方法で浮動小数が固定小数に変換できるのかわかりません。

#####わからない理由を以下に示します。
自分の理解では、floatと固定少数はbitを考えた時構造が全く違うと理解しています。　　
浮動小数値は、符号部・指数部・仮数部に別れます。しかし、固定小数値は、符号部・整数部・小数部にbitが別れています。だから、いくらbitシフトさせようと浮動小数点は固定小数に変換できないと思ってしまいます。そもそも各bit の役割がぜんぜん違うからです。

int型などの整数値を固定小数値に変換するのは理解できます。
整数値は、第１bitの右にバイナリポイント(小数点)があると理解できるので、固定小数に治す場合は小数部のbit分だけ、左bitシフトすればいいからです。

質問の意図伝わりましたでしょうか？
お力をお貸しください。

浮動小数値から固定少数値への変換をどうやって行うか。

### 実現したいこと
cですが、
#include <stdio.h>
にて呼び出すファイルがあるディレクトリーはどこですか？
環境変数に定義していますか？
Windows11
Microsoft Visual Studio
