常連

Visual studio 2019のコンパイラである**clコンパイラ**を使ってコンパイルして.libをリンクして.dllもビルド？したいのですがどうすればいいのでしょうか以下の提示画像のエラーの解決方法が知りたいです。

### 試したこと
１、**Visual studio 2019ではコンパイルが通り実行画面が表示されているためコンパイルエラーではないと思います。**

２、また../を使って今の階層からSDL2ライブラリの.libファイルの場所をしていますが本当にその場所かどうかはエキスプローラーで確認しているためこの場所なのは確認済みです。

３、当然のことながらsourceディレクトリに二つのソースファイル **Game.cpp main.cppが存在しているのは確認済みです**。ウインドウのタイトルを見てわかる通り**clコンパイラが使えるコマンドライン**を使っています。



エラーコード: "LINK : fatal error LNK1561: エントリー ポイントを定義しなければなりません。"
※白く加工してある部分は自分の実名ディレクトリ名です。

参考サイト(windows公式サイト): https://docs.microsoft.com/ja-jp/cpp/build/reference/cl-invokes-the-linker?view=vs-2019


![イメージ説明](2afc6797ff1e334a763bd16665b4c278.png)

clコンパイラで"LINK : fatal error LNK1561: エントリー ポイントを定義しなければなりません。"の解決方法が知りたい。オプションがわからない。

C++初心者です。SDL2を触っています。
SDL2が生ではすこし使いづらいので、自作のちょっとしたライブラリを作ろうとしていたところでのつっかえです。

### 概要

自分で作った構造体を入れるvectorにpush_back()を使って値を格納しようとすると、ちゃんと動作するのですが、
実行後に謎のエラーメッセージ(なのか?)がでます。

```
corrupted size vs. prev_size
中止 (コアダンプ)
```

ネットでサイトや記事もいくつか見て回ったのですが、「範囲外アクセスやメモリリーク等メモリ関連の異常」というところまでは判明したものの、詳しい内容や肝心の解決方法が見当たらず困っています。
(目的のプログラム自体ちゃんと動くので無視するのも手ですが...どうしても気になってしまいます。)


### 質問

以下の質問にできるだけ答えていただきたいです。

(1) どのようにすれば解決できると考えられますか？
(2) vectorに構造体を格納する事自体に問題はありますか？

### ソースコード(抜粋)

原因と思われるpush_back()は下の方、最後あたりにあります。
ちなみにこのpush_back()を消すと、(push_backの機能しない範囲で)ちゃんと実行、終了されます。

```
struct tesdl_object{ //オブジェクト
    short type;
    dxy pos,siz;
    db z;
    RGB col;
    tesdl_object(short ntp=0,dxy nxy={0.0,0.0},db nz=0.0,dxy ns={1,1},RGB nc=RGB(0,0,0)){
        type=ntp;
        pos=nxy;
        z=nz;
        siz=ns;
        col=nc;
    }
    bool operator<(const tesdl_object& tso)const{
        return z<tso.z;
    }
};

struct tesdl_screen{ //スクリーン
    tesdl_object conf;
    vector<tesdl_object> objs;
    set<int> check;
    vector<vector<RGB>> table;

    tesdl_screen(dxy nxy={0,0},db nz=0.0,RGB nc=RGB(1,1,1)){
        conf.pos=nxy;
        conf.z=nz;
        conf.siz=tesdl_system_window;
        conf.col=nc;
        table=tesdl_system_basetable;
        clear();
    }

    void push(tesdl_object qobj){
        objs.push_back(qobj);                      // <-ココ!
    }
}
```


### ソースコード(フル)
下手なコードで申し訳ないです。

core.cpp
```
#include <SDL/SDL.h>
#include <SDL/SDL_image.h>
#include <SDL/SDL_ttf.h>
#include <SDL/SDL_mixer.h>

#include <iostream>
#include <functional>
#include <vector>
#include <queue>
#include <cmath>
#include <algorithm>
#include <string>
#include <array>
#include <map>
#include <set>

using namespace std;

typedef double db;

SDL_Surface* mainSf;

db clamp1(db &a){
    a=min(1.0,max(0.0,a));
}

struct dxy{ //座標
    db x,y;
    int ix,iy;
    dxy(db qx=0,db qy=0){
        x=qx;y=qy;
        ix=x;iy=y;
    }
    
    bool operator<(const dxy& tso)const{
        return y<tso.y or (y==tso.y and x<tso.x);
    }

    dxy operator+(const dxy& tso)const{
        return dxy(x+tso.x,y+tso.y);
    }

    dxy operator-(const dxy& tso)const{
        return dxy(x-tso.x,y-tso.y);
    }

    dxy operator/(const db& tso)const{
        return dxy(x/tso,y/tso);
    }

};

struct RGB{ //色
    db r,g,b,a;
    RGB(db xr=1.0,db xg=1.0,db xb=1.0,db xa=1.0){
        r=xr;
        g=xg;
        b=xb;
        a=xa;
    }
    void clampColor(){
        clamp1(a);
        clamp1(r);
        clamp1(g);
        clamp1(b);
    }
};

RGB getRgb(dxy point);


void colAlpha(RGB &col,dxy point={0,0}){ //色を作る
    RGB qq=getRgb(point);
    
    col.clampColor();

    if(col.a!=1.0){
        col.r=(col.r-qq.r)*col.a+qq.r;
        col.g=(col.g-qq.g)*col.a+qq.g;
        col.b=(col.b-qq.b)*col.a+qq.b;
    }

}


Uint32 toSDLrgb(RGB col,dxy point={0,0}){ //RGBをSDL用に(Uint32へ)変換
    colAlpha(col,point);
    return SDL_MapRGB(mainSf->format,255*col.r,255*col.g,255*col.b);
}

dxy tesdl_system_window={400,400};

int tesdl_system_wait=16;

void tesdl_init(){ //初期化
    SDL_Init(SDL_INIT_VIDEO);
    SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY,SDL_DEFAULT_REPEAT_INTERVAL);
    mainSf=SDL_SetVideoMode(tesdl_system_window.x,tesdl_system_window.y,32,SDL_SWSURFACE|SDL_DOUBLEBUF);
}


RGB getRgb(dxy point){ //指定した座標の色を取得
    Uint32 pixel=*((Uint32*)mainSf->pixels+point.iy*mainSf->w+point.ix);
    Uint8 r,g,b;
    SDL_GetRGB(pixel,mainSf->format,&r,&g,&b);
    return RGB(db((pixel>>16)&0xff)/255.0,db((pixel>>8)&0xff)/255.0,db(pixel&0xff)/255.0);
}

bool pointIn(dxy point){ 
    return point.ix<0 or point.iy<0 or point.ix>tesdl_system_window.x-1 or point.iy>tesdl_system_window.y-1;
}



void putDot(dxy point,RGB col){ //ドットを打つ

    if(pointIn(point))return;  
    
    
    Uint32 pixel=toSDLrgb(col);
    
    int bpp=mainSf->format->BytesPerPixel;
    Uint8 *p=(Uint8*)mainSf->pixels+point.iy*mainSf->pitch+point.ix*bpp;
    *(Uint32*)p=pixel;
}
```



tesdl.cpp
```
#include "core.cpp"

const short
    tesdl_type_rect=0
;

const vector<vector<RGB>> tesdl_system_basetable=vector<vector<RGB>>(tesdl_system_window.y,vector<RGB>(tesdl_system_window.x,RGB(1,1,1,1)));


struct tesdl_object{ //オブジェクト
    short type;
    dxy pos,siz;
    db z;
    RGB col;
    tesdl_object(short ntp=0,dxy nxy={0.0,0.0},db nz=0.0,dxy ns={1,1},RGB nc=RGB(0,0,0)){
        type=ntp;
        pos=nxy;
        z=nz;
        siz=ns;
        col=nc;
    }

    bool operator<(const tesdl_object& tso)const{
        return z<tso.z;
    }
};

struct tesdl_screen{ //スクリーン
    tesdl_object conf;
    vector<tesdl_object> objs;
    set<int> check;
    vector<vector<RGB>> table;

    void clear(){
        check.clear();
        objs={};
        table=tesdl_system_basetable;
    }

    tesdl_screen(dxy nxy={0,0},db nz=0.0,RGB nc=RGB(1,1,1)){
        conf.pos=nxy;
        conf.z=nz;
        conf.siz=tesdl_system_window;
        conf.col=nc;
        table=tesdl_system_basetable;
        clear();
    }

    dxy pointIn(dxy point,db nz){
        dxy qxy;
        qxy.x=(point.x-conf.pos.x);
        qxy.y=(point.y-conf.pos.y);
        return qxy;
    }

    void push(tesdl_object qobj){
        objs.push_back(qobj);                      // <-ココ!
    }

    void setScreen(tesdl_object tso){
        switch(tso.type){
            case tesdl_type_rect:{
                dxy
                    sxy=pointIn(tso.pos-tso.siz/2,tso.z),
                    exy=pointIn(tso.pos+tso.siz/2,tso.z)
                ;

                for(db iy=sxy.y;iy<exy.y;iy++){
                    for(db ix=sxy.x;ix<exy.x;ix++){
                        check.insert(iy*conf.siz.ix+ix);
                        colAlpha(tso.col,{ix,iy});
                        table[iy][ix]=tso.col;
                    }
                }
                break;
            }
        }
        

    }

    void show(){

        SDL_FillRect(mainSf,0,toSDLrgb(conf.col));
        for(auto itr:objs)setScreen(itr);
        dxy ds;
        
        for(auto itr=check.begin();itr!=check.end();++itr){
            int it=*itr;
            ds=dxy(it%conf.siz.ix,it/conf.siz.ix);
            putDot(ds,table[ds.iy][ds.ix]);

        }
        
        clear();
        SDL_Flip(mainSf);
        SDL_Delay(tesdl_system_wait);
        
    }

};
```
main.cpp

```
#include "tesdl.cpp"

int main(){
    tesdl_system_window={400,400};
    tesdl_init();
    bool looping=true;
    SDL_Event ev;
    tesdl_screen sc;

    while(looping){

        //入力用ループ(今回の件については関係なし)
        while(SDL_PollEvent(&ev)){
            switch(ev.type){
                case SDL_QUIT:
                    looping=false;
                    break;
            }
        }

        sc.push(tesdl_object(0,{30,40},0,{64,16},RGB(0,0,0,1))); //オブジェクトを表示
        
        sc.show(); //画面の更新
    }
}
```

[C++]<vector>.push_back()で実行後にエラーメッセージ(corrupted size vs. prev_size)

提示コードですが.**csvファイルを読み込んでint型のvectorの二次元に格納したい**のですがどうすればいいのでしょうか？単に数字だけでなく
,　や改行などを考えて改行の場所でうまく次の配列の先頭から数字を入れてといった処理を作り関数化したいのですがどうすればいいのでしょうか？？取り敢えず作ってみましたがもうわけがわかりません。


![![イメージ説明](3c37588f2f281a516852b797c38349ae.png)
```ここに言語を入力
#include "stdio.h"
#include "stdlib.h"
#include <vector>


int main()
{
    FILE *fp;
   // char *tm = NULL;                       //読み込んだ.csvファイルの文字列
    char tm[5000];                       //読み込んだ.csvファイルの文字列
    const char *filename = "MapLayer1.csv";//.csvファイルを読み込む
    //int *mIndex = ;
    std::vector<std::vector<int>> idx;//マップチップ番号格納
    int c = 0;
    int vi = 0;

    fp = fopen(filename,"r");
    if(fp == NULL)
    {
        printf("読み込み失敗\n");
        exit(1);
    }
    printf("読み込み成功\n");
    while(fscanf(fp, "%s", tm) != EOF)
    {

        printf("%zd\n", strlen(tm));
        printf("%s\n", tm);

        int t = strlen(tm);//文字列の長さを所得
        int i = 0;
        char c[20];
        int a = 0;
        while(true)
        {
            if(tm[i] >= '0' && tm[i] <= '9')
            {
                c[a] = tm[i];
                a++;
            }else
            {
                long k;
                a = 0;

                k = strtol(c,NULL,0);//文字列を数字に変換して最後のidx配列の配列に書き込む
                idx.at(vi).push_back(k);
                memset(c, '\0', sizeof(c)); //一時文字列変数をリセット
            }
        }

        idx.emplace_back();//1次元目に一つ要素を追加
        vi++;
    }

    return 0;
}
```

.csvファイルを読み込んでint型の二次元vector配列に格納する方法が知りたい。

# 質問内容
提示コードの`void Engine::SpriteRenderer::Render()`関数部ですが`SDL_Texture* texture = IMG_LoadTexture(Context::GetRenderer(),"./tile4.png");`を使うと正常に描画できるのですが`sprite.handle`を使って描画すると描画されません。これはなぜでしょうか？　非同期で画像ロードしてしっかりと待機していて同じポインターを指しているのですが原因がわかりません。デストラクタ等は定義、宣言していません。

# 知りたいこと
画像が描画できない原因が知りたい

# 確認したいこと
`SDL_GetError()`を実行しましたが何も表示されていません。

#ソースコード　全文
##### 画像ロード関数
```cpp
#include <iostream>
#include <Context.hpp>
#include <vector>
#include <functional>
#include <future>
#include <iostream>
#include <glm/glm.hpp>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <chrono>
#include <random>
#include <thread>

struct Sprite
{
    SDL_Texture *handle;
    std::string path;
};


std::vector<Sprite> sprites;            //ロードした画像リスト
std::vector<std::string> nowLoad;       //現在ロード中の画像リスト 
std::mutex loadMutex;
std::condition_variable loadCV;

std::chrono::_V2::system_clock::time_point startTime;

void SetStartTime()
{
    startTime = std::chrono::high_resolution_clock::now();
}

int GetEndTime()
{

    auto endTime = std::chrono::high_resolution_clock::now();
    auto time = std::chrono::duration_cast<std::chrono::milliseconds>(endTime - startTime);

    return time.count();
}

/*##############################################################
# 乱数取得
##############################################################*/
int GetRandom(int rand)
{
    // 現在の時間を取得して種(seed)として使用する
    auto now = std::chrono::high_resolution_clock::now();
    auto seed = std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch()).count();

    // 乱数生成器を初期化
    std::mt19937_64 generator(seed);

    // ミリ秒単位の乱数を生成
    std::uniform_int_distribution<int> distribution(0, rand);
    int random_number = distribution(generator);

    //std::cout << "ミリ秒単位の乱数: " << random_number << std::endl;

    return random_number;
}

/*##############################################################

# 非同期　版

# スプライトロード関数　
※　テスト用のためロード時間を乱数でミリ秒待機
##############################################################*/
Sprite LoadSprite(const char* filePath)
{
    std::unique_lock<std::mutex> lock(loadMutex);

    // 他のスレッドが同じ画像をロード中であれば待機
    loadCV.wait(lock, [&filePath]() 
    {
        for(const std::string& path : nowLoad) 
        {
            if (path == std::string(filePath)) 
            {
                return false;
            }
        }
    
        return true;
    });

    //スプライトリストから取り出す
    for (const Sprite& s : sprites)
    {
        if (s.path == std::string(filePath))
        {
            std::cout << "found sprite" << std::endl;
            return s;
        }
    }

    std::cout << "new sprite" << std::endl;

    // ロード中の画像リストに追加
    nowLoad.push_back(std::string(filePath));
    lock.unlock();  // ロックを解除して他のスレッドがロードを開始できるようにする

    //画像ロード
//    int milliseconds = 1000;
    //int milliseconds = GetRandom(1000);
//    std::this_thread::sleep_for(std::chrono::milliseconds(milliseconds));
    SDL_Texture *texture = IMG_LoadTexture(Engine::Context::GetRenderer(),"tile4.jpg");

    lock.lock();  // ロックを再取得して安全に状態を更新する


    //ロードが終わったためリストから削除
    int i = 0;
    for(const std::string& s : nowLoad)
    {
        if(s == filePath)
        {
           break; 
        }

        i++;
    }
    nowLoad.erase(nowLoad.begin() + i);

    //ロード済みスプライトリストに追加
    sprites.push_back(Sprite{texture, std::string(filePath) });
    //sprites.push_back(Sprite{ milliseconds, std::string(filePath) });

    // 画像のロードが完了したことを通知
    loadCV.notify_all();

    return sprites.back(); 
}

/*##############################################################

# 同期　版

# スプライトロード関数　
※　テスト用のためロード時間を乱数でミリ秒待機
##############################################################*/


/*##############################################################
# Component 基底
##############################################################*/
class GameObject;
class Component
{
public:
    
GameObject *gameObject;
    Component(GameObject* g)
    {
        gameObject = g;
    }

    virtual std::vector<std::future<void>> PreLoad()
    {

        return std::move(futures);
    }


    virtual void Start() = 0;

    virtual void Update() = 0;

    virtual void Render()
    {
        
    }

protected:

    std::vector<std::future<void>> futures;
};
/*##############################################################
# GameObject 基底
##############################################################*/
class GameObject
{
public:

    GameObject()
    {

    }

    std::vector<std::future<void>> getPreLoad()
    {
        std::vector<std::future<void>> process;

        for(Component *c : components)
        {
            for(std::future<void> &f : c->PreLoad())
            {
                process.push_back(std::move(f));
            }
        }

        return std::move(process);
    }


    void Start()
    {
       for(Component* c : components)
       {
            c->Start();
       } 
    }
    void Update()
    {
        for(Component* c : components)
        {
            c->Update();
        } 
    }

    void Render()
    {
        for(Component* c : components)
        {
            c->Render();
        } 
    }

    std::vector<Component*> components;
};

/*##############################################################
# Scene 基底
##############################################################*/
class Scene
{
public: 

    std::vector<GameObject*> gameObjects;
    void PreaLoad()
    {
        std::vector<std::future<void>> futures;
        for(GameObject *g : gameObjects)
        {
            for(std::future<void> &f : g->getPreLoad())
            {
                futures.push_back(std::move(f));
            }
        }


        SetStartTime();
        for(std::future<void> &f : futures)
        { 
            f.wait();
        }

        int time = GetEndTime();
        std::cout<<time<<std::endl;
    }


    void Update()
    {
        for(GameObject *g : gameObjects)
        {
            g->Update();
        } 
    }

    void Render()
    {
        for(GameObject *g : gameObjects)
        {
            g->Render();
        } 
    }

 
};

/*##############################################################
# SpriteRenderer コンポーネント
##############################################################*/
class SpriteRenderer : public Component
{
public:

    Sprite sprite;
    SpriteRenderer(GameObject* g): Component(g)
    {

    }

    void Start() override
    {

    }

    void Update() override
    {

    }

    void Render() override
    {
        SDL_Texture* texture = IMG_LoadTexture(Engine::Context::GetRenderer(),"tile4.jpg");
        SDL_Rect rect =  {0,0,64,64};
        SDL_Rect dest =  {100,100,64,64};

        //std::cout<<"Render"<<std::endl;
        //SDL_RenderCopy(Engine::Context::GetRenderer(),texture,&rect,&dest);
        SDL_RenderCopy(Engine::Context::GetRenderer(),sprite.handle,&rect,&dest);
        //SDL_RenderCopy(Engine::Context::GetRenderer(),sprite.handle,&rect,&dest);

        std::cout<<SDL_GetError()<<std::endl;
    }
};


/*##############################################################
# Control コンポーネント
##############################################################*/
class SpriteRenderer;
class Control : public Component
{
public:
    Control(GameObject *g): Component(g)
    {
        
    }

    std::vector<std::future<void>> PreLoad() override
    {

    
        futures.push_back(std::async(std::launch::async,[this](){ ((SpriteRenderer*)(gameObject->components.at(0)))->sprite = LoadSprite("tile4.jpg");  }));



       return std::move(futures); 
    }

    void Start()
    {

    }

    void Update()
    {

    }
};
/*##############################################################
# Player ゲームオブジェクト
##############################################################*/
class Player : public GameObject
{
public:
    Player(): GameObject()
    {
        components.push_back(new SpriteRenderer(this));
        components.push_back(new Control(this));
    }



    
};




/*##############################################################
# Game シーン
##############################################################*/
class Game : public Scene
{
public:
    Game(): Scene()
    {
        gameObjects.push_back(new Player());
    };


    void PreLoad()
    {
        for(std::future<void> &f : gameObjects.at(0)->getPreLoad())
        {
            f.wait();
        }   
    }

    void Start()
    {
        gameObjects.at(0)->Start();
    }

    void Update()
    {

        gameObjects.at(0)->Update();
    }

    void Render()
    {
        gameObjects.at(0)->Render();
    }
};




int main()
{
    Engine::Context::Init("Game",glm::ivec2(680,480));
    Game *g = new Game();

    g->PreLoad();

        g->Start();
    while(true)
    {
        Engine::Context::ClearBuffer();
        if(Engine::Context::GetKey(SDL_SCANCODE_ESCAPE) == true)
        {
            break;
        }


        g->Update();
        g->Render();

        Engine::Context::RenderBuffer();
    }


    Engine::Context::Finalize();
    return 0;
}
```

std::future,std::asyncを使った非同期で読み込んだ画像が描画されない原因が知りたい

#環境
Visual Studio 2019
#質問内容
SDL_imageの関数を参照できずビルドできない
SDL.hの関数のみだとビルドできましたが、IMG_Loadなどを入れるとビルドできなくなります。
ソースコードにエラーが出ないため、上手く導入できていないのだと思います。
予測変換は出るのでincludeのほうはちゃんと導入できていると思います。
該当関数にカーソルを合わせると説明も出ます。
#やったこと
SDL 2.0のダウンロードはgithubから行いました。
C:\Users...\Desktop\game_practice\own_pra\pra2\include\~.h
C:\Users...\Desktop\game_practice\own_pra\pra2\lib\x86\~.dll
それぞれのパスです。
プロジェクトフォルダの中にincludeとlibをコピーしてあります。
https://suzutsuki.org/2018/05/22/sdl-setup-project
こちらのサイト通り設定しました。
#エラーメッセージ
未解決の外部シンボル _IMG_Init が関数 "public: void __thiscall Init::Run(void)(?"Run@Init@@QAEXXZ) で参照されました。

未解決の外部シンボル _IMG_Quit が関数 "public: void __thiscall Init::Shutdown(void)" (?Shutdown@Init@@QAEXXZ) で参照されました。	


未解決の外部シンボル _IMG_Load が関数 "public: void __thiscall Init::Run(void)" (?Run@Init@@QAEXXZ) で参照されました。

３件の未解決の外部参照

SDLの導入について

##### 質問内容
提示コードですが非同期処理を用いて、アセットを非同期でロードする処理なのですが現状３つの画像がそれぞれ順番にロードされてしまう原因が知りたいです。
提示コードの非同期版のコードでは同じ画像が来た時待機するという処理を行っているのですが、なぜか同期版と同じ秒数処理時間がかかっているため同期処理と同じになって
いると考えられます。

##### 調べたこと
非同期版と同期版両方のプログラムを記述して実行時間を計測

##### 知りたいこと
１，アセットのロードで同じファイルがロードされないようにしながら非同期で行いたい。
２，そもそもどの非同期機能を使ってアセットロードを実装するのが定番なのか知りたいです。

##### 提示コードについて
提示コードはコンポーネント指向を用いています。Componentを継承して非同期で行うアセットロード処理を作り、それをGameObject(コンポーネントをの挙動を管理する)で
処理をまとめて、更に上のSceneで全部のGameObject の非同期処理を一つにまとめ、最後に全部が終わるまで待機してからUpdate()等を実行するという処理内容です。


##### コンソール
```
new sprite
found sprite
new sprite
2000
```

##### ソースコード
```cpp
#include <vector>
#include <future>
#include <iostream>
#include <glm/glm.hpp>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <chrono>
#include <random>
#include <thread>

struct Sprite
{
    int handle;
    std::string path;
};


std::vector<Sprite> sprites;            //ロードした画像リスト
std::vector<std::string> nowLoad;       //現在ロード中の画像リスト 
std::mutex loadMutex;
std::condition_variable loadCV;


/*##############################################################
# 乱数取得
##############################################################*/
int GetRandom(int rand)
{
    // 現在の時間を取得して種(seed)として使用する
    auto now = std::chrono::high_resolution_clock::now();
    auto seed = std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch()).count();

    // 乱数生成器を初期化
    std::mt19937_64 generator(seed);

    // ミリ秒単位の乱数を生成
    std::uniform_int_distribution<int> distribution(0, rand);
    int random_number = distribution(generator);

    //std::cout << "ミリ秒単位の乱数: " << random_number << std::endl;

    return random_number;
}

/*##############################################################

# 非同期　版

# スプライトロード関数　
※　テスト用のためロード時間を乱数でミリ秒待機
##############################################################*/
Sprite LoadSprite(const char* filePath)
{
    std::unique_lock<std::mutex> lock(loadMutex);

    // 他のスレッドが同じ画像をロード中であれば待機
    loadCV.wait(lock, [&filePath]() 
    {
        for(const std::string& path : nowLoad) 
        {
            if (path == std::string(filePath)) 
            {
                return false;
            }
        }
    
        return true;
    });

    //スプライトリストから取り出す
    for (const Sprite& s : sprites)
    {
        if (s.path == std::string(filePath))
        {
            std::cout << "found sprite" << std::endl;
            return s;
        }
    }

    std::cout << "new sprite" << std::endl;

    // ロード中の画像リストに追加
    nowLoad.push_back(std::string(filePath));
    lock.unlock();  // ロックを解除して他のスレッドがロードを開始できるようにする

    //画像ロード
    int milliseconds = 1000;
    //int milliseconds = GetRandom(1000);
    std::this_thread::sleep_for(std::chrono::milliseconds(milliseconds));


    lock.lock();  // ロックを再取得して安全に状態を更新する


    //ロードが終わったためリストから削除
    int i = 0;
    for(const std::string& s : nowLoad)
    {
        if(s == filePath)
        {
           break; 
        }

        i++;
    }
    nowLoad.erase(nowLoad.begin() + i);

    //ロード済みスプライトリストに追加
    sprites.push_back(Sprite{ milliseconds, std::string(filePath) });

    // 画像のロードが完了したことを通知
    loadCV.notify_all();

    return sprites.back();

    
}

/*##############################################################

# 同期　版

# スプライトロード関数　
※　テスト用のためロード時間を乱数でミリ秒待機
##############################################################*/
Sprite Sync_LoadSprite(const char* filePath)
{
   //スプライトリストから取り出す
    for (const Sprite& s : sprites)
    {
        if (s.path == std::string(filePath))
        {
            std::cout << "found sprite" << std::endl;
            return s;
        }
    }

    std::cout << "new sprite" << std::endl;

    //画像ロード
    int milliseconds =1000;
    //int milliseconds = GetRandom(1000);
    std::this_thread::sleep_for(std::chrono::milliseconds(milliseconds));


   //ロード済みスプライトリストに追加
    sprites.push_back(Sprite{ milliseconds, std::string(filePath) });

    return sprites.back();

    
}





/*##############################################################
# Component 基底
##############################################################*/
class Component
{
public:
    
    Component()
    {

    }

    virtual void (*PreLoad())()
    {
        return []() -> void
        {
            std::cout<<"component"<<std::endl;
        };
    }
    
};
/*##############################################################
# GameObject 基底
##############################################################*/
class GameObject
{
public: 
    GameObject()
    {

    }

    std::vector<std::future<void>> getPreLoad()
    {
        std::vector<std::future<void>> futures;

        for(Component *c : components)
        {
            futures.push_back(std::async(std::launch::async,c->PreLoad()));
        }

        return futures;
    }

    void Update()
    {

    }

    void Render()
    {

    }

    std::vector<Component*> components;
};

/*##############################################################
# Scene 基底
##############################################################*/
class Scene
{
public: 

    std::vector<GameObject*> gameObjects;
    void Preaload()
    {
        std::vector<std::future<void>> futures;
        for(GameObject *g : gameObjects)
        {
            for(std::future<void> &f : g->getPreLoad())
            {
                futures.push_back(std::move(f));
            }
        }

        for(std::future<void> &f : futures)
        {
            f.wait();
        }
    }

};

/*##############################################################
# Control コンポーネント
##############################################################*/
class Control : public Component
{
public:
    Control(): Component()
    {
        
    }

    void (*PreLoad())() override
    {
        return []() ->void 
        {


// 同期
/*
            auto startTime = std::chrono::high_resolution_clock::now();
 
            Sprite sp1 = Sync_LoadSprite("tile1.jpg");
            Sprite sp2 = Sync_LoadSprite("tile1.jpg");
            Sprite sp3 = Sync_LoadSprite("tile2.jpg");
            
            auto endTime = std::chrono::high_resolution_clock::now();
            auto time = std::chrono::duration_cast<std::chrono::milliseconds>(endTime - startTime);

            std::cout<<time.count()<<std::endl;
*/

//非同期
            auto startTime = std::chrono::high_resolution_clock::now();
 
            Sprite sp1 = LoadSprite("tile1.jpg");
            Sprite sp2 = LoadSprite("tile1.jpg");
            Sprite sp3 = LoadSprite("tile2.jpg");
            
            auto endTime = std::chrono::high_resolution_clock::now();
            auto time = std::chrono::duration_cast<std::chrono::milliseconds>(endTime - startTime);

            std::cout<<time.count()<<std::endl;







        };
    }
};

/*##############################################################
# Player ゲームオブジェクト
##############################################################*/
class Player : public GameObject
{
public:
    Player(): GameObject()
    {
        components.push_back(new Control());
    }
};

/*##############################################################
# Game シーン
##############################################################*/
class Game : public Scene
{
public:
    Game(): Scene()
    {
        gameObjects.push_back(new Player());
    }
};




int main()
{

    Game *g = new Game();

    g->Preaload();



    return 0;
}
```

[ゲーム開発] 非同期のアセットのロードで同じファイルがロードされない仕組みを作りたい

### 前提・実現したいこと

誰か分かる方、助けてください...！
レポートで、C言語のSDLライブラリを用いた以下のプログラムを書いています。

・ウィンドウに，円と四角を描画する
・マウス（カーソル）の現在座標をウィンドウ上に表示する（stringColor関数，sprintf関数を使う）
・円をマウスでドラッグアンドドロップできる
・円を四角の中にドロップすると，“GoodJob!”という文字列をウィンドウの中央付近に表示する
・プログラムの終了条件を入れるなど，自分なりのアレンジを加えても良い 

ということで書いてみて、コンパイルが通るところまではいったのですが、実行するとコアダンプが起きます。
授業のスライドを何度も見返して何時間も格闘したのですが、結局分かりませんでした...。
### 発生している問題・エラーメッセージ

$ gcc kadai1.c -lSDL2 -lSDL2_gfx -lSDL2_ttf -lSDL2_image -lSDL2_mixer
$ ./a.out
Segmentation fault (コアダンプ)

### 該当のソースコード<kadai1.c>(無駄にincludeしていると思います、すみません。)

```
#include <stdio.h>
#include <SDL2/SDL.h>
#include <SDL2/SDL_image.h>
#include <SDL2/SDL_mixer.h>
#include <SDL2/SDL_ttf.h>
#include <SDL2/SDL2_gfxPrimitives.h> 
#include <SDL2/SDL_net.h>

int main(int argc, char *argv[]){

	int x = 500;
	int y = 500;//マウスの座標を格納
	int a = 0; //SDL_MOUSEBUTTONUP施行のタイミングの制御
	int b = 0; //Good job!!描画の制御
	char s[64];//マウス座標を格納するための文字列
	char f[64];//起動時にマウス座標を表示するための文字列
	
	SDL_Window *window ; // ウィンドウのデータを格納する構造体
    	SDL_Renderer *renderer; //最初に丸と四角を表示させておくためのレンダラー
    	SDL_Event event; // SDLによるイベントを検知するための構造体
    	SDL_Event quit_event = {SDL_QUIT}; // 特定のイベント名を格納
    	SDL_Surface *f_strings; // サーフェイス（メインメモリ上の描画データ）を格納する構造体
  	SDL_Surface *strings; // サーフェイス（メインメモリ上の描画データ）を格納する構造体
    	SDL_Texture *f_texture; // テクスチャ（VRAM上の描画データ）を格納する構造体
    	SDL_Texture *texture; // テクスチャ（VRAM上の描画データ）を格納する構造体
    	TTF_Font* font; // TrueTypeフォントデータを格納する構造体
	SDL_Color white = {0x00, 0x00, 0x00, 0xFF};	// フォントの色を指定するための構造体（白色）
    	SDL_Color blue = {0x00, 0x00, 0xFF, 0xFF};	// フォントの色を指定するための構造体（青色）
	
	if(SDL_Init(SDL_INIT_EVERYTHING) < 0) {
		printf("failed to initialize SDL.\n");
		exit(-1);
        }// SDL初期化（初期化失敗の場合は終了）
	
	// ウィンドウ生成・表示
	window = SDL_CreateWindow("Press [Esc] to exit",SDL_WINDOWPOS_CENTERED,SDL_WINDOWPOS_CENTERED,960,720,0);
	if(window == NULL){
		printf("Failed to create window.\n");
		exit(-1);
	}
	
	sprintf(f,"x,y=%d,%d",0,0);
	SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "linear");  // 拡大縮小を滑らかにする（線形フィルタで）
	TTF_Init(); // TrueTypeフォントを用いるための初期化
	font = TTF_OpenFont("./migu.ttf", 24); // fonts-japanese-gothicフォントを12ポイントで使用（読み込み）
    	
    	// レンダラー作成
	renderer = SDL_CreateRenderer(window, -1, 0);
	SDL_SetRenderDrawColor(renderer, 255, 255, 255, 0);//生成したRCに描画色として白を設定
	SDL_RenderClear(renderer);//白で塗りつぶす
	
    	rectangleColor(renderer, 600, 400, 850, 600, 0xff0000ff);// 生成したウィンドウに対してレンダリングコンテキスト（RC）を生成
    	filledCircleColor(renderer, x, y, 25, 0xff0000ff);
    	
    	strings = TTF_RenderUTF8_Blended(font, "x,y = 0,0", white);//描画文字の作成と格納
	texture = SDL_CreateTextureFromSurface(renderer, strings);//サーフェイスからテクスチャへ変換
	
	// 文字列描画（表示）のための設定
	SDL_Rect src_rect = {0, 0, strings->w, strings->h};//コピー元文字列の領域（x, y, w, h）（strings->wとstrings->hにはそれぞれ文字列の横幅と高さが格納される）
	SDL_Rect dst_rect = {10, 0, 100, 50};//文字列のコピー先の座標と領域（x, y, w, h）
	SDL_RenderCopy(renderer, texture, &src_rect, &dst_rect);   // テクスチャをRCにコピー（設定のサイズで） 	
    	
    	SDL_RenderPresent(renderer); // 描画データを表示
    	
    	
    	
    	while(1){
        // イベントを取得したなら
        	if(SDL_PollEvent(&event)){
            // イベントの種類ごとに処理
            	switch (event.type) {
		    	case SDL_MOUSEMOTION: // マウスが移動した時
			    	printf("Mouse moved by %d,%d to (%d,%d)\n", event.motion.xrel, event.motion.yrel, event.motion.x, event.motion.y); // マウスの座標を表示
			    	sprintf(s,"x,y=%d,%d",event.motion.x, event.motion.y);
			    	strings = TTF_RenderUTF8_Blended(font, s, white); // 描画文字の作成と格納
			    	texture = SDL_CreateTextureFromSurface(renderer, strings); // サーフェイス（文字列の描画データが格納されている）からRCのテクスチャを生成（サーフェイスからテクスチャへ変換）
			    	SDL_Rect src_rect = {0, 0, strings->w, strings->h}; // コピー元文字列の領域
			    	SDL_RenderCopy(renderer, texture, &src_rect, &dst_rect); // テクスチャをRCにコピー（設定のサイズで）
			    	SDL_RenderPresent(renderer); // 描画データを表示
			    	break;
		    	
		    	
		    	case SDL_MOUSEBUTTONDOWN: // マウスボタンが押された時
				printf("Mouse button %d pressed at (%d,%d)\n",event.button.button, event.button.x, event.button.y);// 押されたマウスのボタン等を表示
				if(event.button.x - x <= 25 && event.button.y <=25 && event.button.x >= -25 && event.button.y >= -25){
					a = 1;
					break;
				}
				break;
			
			case SDL_MOUSEBUTTONUP: if(a==1){ //マウスボタンが離された時
				printf("Mouse button up at (%d,%d)\n", event.button.x, event.button.y);//マウスを離した地点
				filledCircleColor(renderer, event.button.x, event.button.y, 50, 0xff0000ff);
				x = event.button.x;
				y = event.button.y;
				a = 0;
				SDL_SetRenderDrawColor(renderer, 255, 255, 255, 0); // 生成したRCに描画色として白を設定
                    		SDL_RenderClear(renderer); // 生成したRCを白でクリア＝塗りつぶす（ただし，メモリに描画データを反映させただけなので，画面には表示されない）
				rectangleColor(renderer,600,400,850,600,0xff0000ff);
				
				if ( event.motion.x <= 850 && event.motion.x >= 600 && event.motion.y <= 600 && event.motion.y >= 400 ){
					f_strings = TTF_RenderUTF8_Blended(font, "Good job!!", blue); // 描画文字の作成と格納（白色のfonts-japanese-gothicフォントで，文字列をサーフェイスに描画＝データとして格納）
					f_texture = SDL_CreateTextureFromSurface(renderer, f_strings); // サーフェイス（文字列の描画データが格納されている）からRCのテクスチャを生成（サーフェイスからテクスチャへ変換）
					// 文字列描画（表示）のための設定
                    			SDL_Rect src_rect = {0, 0, f_strings->w, f_strings->h}; // コピー元文字列の領域
                    			SDL_Rect dst_rect = {410, 320, 100, 50}; // 文字列のコピー先の座標と領域（x, y, w, h）
                    			SDL_RenderCopy(renderer, f_texture, &src_rect, &dst_rect); // テクスチャをRCにコピー（設定のサイズで）
                    			SDL_RenderPresent(renderer); // 描画データを表示
                    			b = 1;
                    			break;
				}
				b = 0;
			}	
	
                	break;
		   	    		
            		case SDL_KEYDOWN: // キーボードのキーが押された時
            			switch(event.key.keysym.sym){
					case SDLK_ESCAPE: // Escキーが押された時
						printf("ESCAPE key -> EXIT.\n");
						SDL_Quit();
						exit(0);
						break;
				        
                    	}
                    	
                    	break;
				
			
			case SDL_QUIT:// SDLの利用を終了する時（イベントキューにSDL_QUITイベントが追加された時）
				TTF_CloseFont(font); // 使用したフォントを閉じる
				TTF_Quit();	// TTFライブラリの使用を終了
				SDL_FreeSurface(strings); // サーフェイスの解放
				SDL_DestroyRenderer(renderer);// RCの破棄（解放）
				SDL_DestroyWindow(window);// 生成したウィンドウの破棄（消去）
				SDL_Quit();
				exit(0);
				break;
            		}
            		
            		//レンダラー再描画
            		SDL_SetRenderDrawColor(renderer, 255, 255, 255, 0); // 生成したRCに描画色として白を設定
            		SDL_RenderClear(renderer); // 生成したRCを白でクリア＝塗りつぶす（ただし，メモリに描画データを反映させただけなので，画面には表示されない）
            		strings = TTF_RenderUTF8_Blended(font, s, white); // 描画文字の作成と格納
            		texture = SDL_CreateTextureFromSurface(renderer, strings); //サーフェイスからテクスチャへ変換
            		SDL_Rect src_rect = {0, 0, strings->w, strings->h}; // コピー元文字列の領域（x, y, w, h）
            		SDL_Rect dst_rect = {10, 0, 100, 50}; // 文字列のコピー先の座標と領域（x, y, w, h）
            		SDL_RenderCopy(renderer, texture, &src_rect, &dst_rect); // テクスチャをRCにコピー（設定のサイズで）
            		
            		filledCircleColor(renderer,x,y,25,0xff0000ff);
            		rectangleColor(renderer,600,400,850,600,0xff0000ff);
            		if( b==1 ){
                    		SDL_Rect dst_rect = {410, 320, 100, 50}; // 文字列のコピー先の座標と領域（x, y, w, h）    
            			SDL_RenderCopy(renderer, f_texture, &src_rect, &dst_rect); // テクスチャをRCにコピー（設定のサイズで）
            		}
   		 		
    			SDL_RenderPresent(renderer); // 描画データを表示
		
    		}
    	}
    	
    	return 0;
}


```


### 試したこと

仮想LINUX環境で、gdbコマンドでデバッグしてコアダンプの原因を調べるという方法も、ネットで調べながら試したのですがエラーが起こっている肝心の関数名が「??」と表示されていて、分かりませんでした。
ポインタを多く使っているので、そこを間違えているのかなと思いましたが、私の目では問題を見つけられませんでした。（実力不足という意味で）
助けてください...。

### 補足情報

PCはWindowsですが、VMwareでUbuntoの仮想環境を使っています。
プログラムではSDLライブラリも使います。

SDLの基礎的なプログラムで、コアダンプの原因が分かりません

### 前提・実現したいこと
SDL2を用いたc言語でのプログラミング。のコンパイルエラー

コンパイル方法：gcc sdl2_font.c -lSDL2 -lSDL2_ttf -L/usr/local/lib -I/usr/local/include/SDL2 -Wl,-rpath,/usr/local/lib 

ヘッダーに#include <SDL2/SDL_ttf.h>を入れるとエラーが出てしまいます。

### 発生している問題・エラーメッセージ

```
/usr/include/SDL2/SDL_keycode.h:101:5: error: redeclaration of enumerator ‘SDLK_e’
     SDLK_e = 'e',
     ^
In file included from /usr/local/include/SDL2/SDL_keyboard.h:33:0,
                 from /usr/local/include/SDL2/SDL_events.h:34,
                 from /usr/local/include/SDL2/SDL.h:41,
                 from sdl2_font.c:15:
一部切り取りです。
```

### 該当のソースコード

```c言語
原因となるソースコード
#include <stdio.h>
#include <SDL2/SDL.h> // SDLを用いるために必要なヘッダファイルをインクルード
#include <SDL2/SDL_ttf.h> // TrueTypeフォントを表示するために必要なヘッダファイルをインクルード

// メイン関数（コマンドライン引数を受け取る）
int main(int argc, char *argv[])
{
    SDL_Window* window; // ウィンドウデータを格納する構造体
    SDL_Renderer* renderer; // レンダリングコンテキスト（描画設定）を格納する構造体
    SDL_Surface* strings; // サーフェイス（メインメモリ上の描画データ）を格納する構造体
    SDL_Texture* texture; // テクスチャ（VRAM上の描画データ）を格納する構造体
    TTF_Font* font; // TrueTypeフォントデータを格納する構造体
    SDL_Color white = {0xFF, 0xFF, 0xFF, 0xFF};	// フォントの色を指定するための構造体（白色）

    // SDL初期化
    SDL_Init(SDL_INIT_VIDEO);

    // ウィンドウ生成・表示
    window = SDL_CreateWindow("Test",SDL_WINDOWPOS_CENTERED,SDL_WINDOWPOS_CENTERED,640,480,0);

    // レンダリングコンテキスト（RC）作成
    renderer = SDL_CreateRenderer(window, -1, 0);
    SDL_SetRenderDrawColor(renderer, 0, 0, 0, 0);
    SDL_RenderClear(renderer);
    // 出力デバイスの違いに対応
    SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "linear");  // 拡大縮小を滑らかにする（線形フィルタで）
    SDL_RenderSetLogicalSize(renderer, 640, 480); // デバイスに依存しない分解能を設定

    
    // 文字列描画処理
    TTF_Init(); // TrueTypeフォントを用いるための初期化
    font = TTF_OpenFont("./fonts-japanese-gothic.ttf", 12); // fonts-japanese-gothicフォントを12ポイントで使用（読み込み）
    strings = TTF_RenderUTF8_Blended(font, "Hello!\nこんにちは！改行するには？…", white); // 描画文字の作成と格納（白色のfonts-japanese-gothicフォントで，文字列をサーフェイスに描画＝データとして格納）

    // RCテクスチャ作成
    texture = SDL_CreateTextureFromSurface(renderer, strings); // サーフェイス（文字列の描画データが格納されている）からRCのテクスチャを生成（サーフェイスからテクスチャへ変換）

    // 文字列描画（表示）のための設定
    SDL_Rect src_rect = {0, 0, strings->w, strings->h}; // コピー元文字列の領域（x, y, w, h）（strings->wとstrings->hにはそれぞれ文字列の横幅と高さが格納される）
    SDL_Rect dst_rect = {0, 0, 640, 480}; // 文字列のコピー先の座標と領域（x, y, w, h）
    SDL_RenderCopy(renderer, texture, &src_rect, &dst_rect); // テクスチャをRCにコピー（設定のサイズで）
//    SDL_RenderCopyEx(renderer, texture, &src_rect, &dst_rect, 45, NULL, SDL_FLIP_HORIZONTAL); // テクスチャをその中心で45度回転させ水平方向に反転させてRCにコピー

    SDL_RenderPresent(renderer); // 描画データを表示

    SDL_Delay(5000);

    // 終了処理
    TTF_CloseFont(font); // 使用したフォントを閉じる
    TTF_Quit();	// TTFライブラリの使用を終了
    SDL_FreeSurface(strings); // サーフェイスの解放
    SDL_DestroyTexture(texture); // テクスチャの解放
    SDL_DestroyRenderer(renderer);
    SDL_DestroyWindow(window);
    SDL_Quit();

    return 0;
}
```


### 試したこと

sudo apt-get update
sudo apt-get upgradeなど、最新のバージョンとした。


### 補足情報（FW/ツールのバージョンなど）

授業ように配布された仮想環境を用いています。

SDL2 (Simple DirectMedia Layer2)