常連

### 前提・実現したいこと
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を用いるC言語のコンパイルエラー

# 質問内容
提示コードの`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を使った非同期で読み込んだ画像が描画されない原因が知りたい

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

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

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

##### 提示コードについて
提示コードはコンポーネント指向を用いています。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;
}
```

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

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配列に格納する方法が知りたい。

### 前提・実現したいこと

プログラミングは趣味でpythonを少し触る程度です。

アプリを作ってみようと思ったので、https://www.youtube.com/watch?v=usbEwmOIhwo&t=265s　この動画をみてやってみました。visual studioなるものをとりあえず入れてみて、その4分ちょいにある下記のコードを実行したところ「例外がスローされました　１」と表示され、動きませんでした。
出力のところを見ると、_window_sdl2というものがimportできてないっぽいですかね。

アプリは、簡単に言うと部活の対戦成績の管理に役立てようと思って、シンプルなものを作ろうとしています。visual studioを初めて使ったので、その辺もよくわかっていないです。ご教授願います。

### 発生している問題・エラーメッセージ

```
[INFO   ] [Logger      ] Record log in C:\Users\tomoy.kivy\logs\kivy_21-07-04_9.txt
[INFO   ] [deps        ] Successfully imported "kivy_deps.angle" 0.3.0
[INFO   ] [deps        ] Successfully imported "kivy_deps.glew" 0.3.0
[INFO   ] [deps        ] Successfully imported "kivy_deps.sdl2" 0.3.1
[INFO   ] [Kivy        ] v2.0.0
[INFO   ] [Kivy        ] Installed at "C:\Users\tomoy\AppData\Local\Packages\PythonSoftwareFoundation.Python.3.9_qbz5n2kfra8p0\LocalCache\local-packages\Python39\site-packages\kivy\__init__.py"
[INFO   ] [Python      ] v3.9.5 (tags/v3.9.5:0a7dcbd, May  3 2021, 17:27:52) [MSC v.1928 64 bit (AMD64)]
[INFO   ] [Python      ] Interpreter at "C:\Users\tomoy\AppData\Local\Microsoft\WindowsApps\PythonSoftwareFoundation.Python.3.9_qbz5n2kfra8p0\python.exe"
[INFO   ] [Factory     ] 186 symbols loaded
[INFO   ] [Image       ] Providers: img_tex, img_dds, img_pil (img_sdl2, img_ffpyplayer ignored)
[CRITICAL] [Window      ] Unable to find any valuable Window provider. Please enable debug logging (e.g. add -d if running from the command line, or change the log level in the config) and re-run your app to identify potential causes
sdl2 - ImportError: DLL load failed while importing _window_sdl2: 指定されたモジュールが見つかりません。
  File "C:\Users\tomoy\AppData\Local\Packages\PythonSoftwareFoundation.Python.3.9_qbz5n2kfra8p0\LocalCache\local-packages\Python39\site-packages\kivy\core\__init__.py", line 58, in core_select_lib
    mod = __import__(name='{2}.{0}.{1}'.format(
  File "C:\Users\tomoy\AppData\Local\Packages\PythonSoftwareFoundation.Python.3.9_qbz5n2kfra8p0\LocalCache\local-packages\Python39\site-packages\kivy\core\window\window_sdl2.py", line 27, in <module>
    from kivy.core.window._window_sdl2 import _WindowSDL2Storage

[CRITICAL] [App         ] Unable to get a Window, abort.

```

### 該当のソースコード

```python
from kivy.app import App

App().run()
```

### 試したこと
「.NETFramework,Version=v4.0 の参照アセンブリが見つかりませんでした。この問題を解決するには、このフレームワーク バージョンの Developer Pack (SDK/Targeting Pack) をインストールするか、アプリケーションのターゲットを再設定してください。https://aka.ms/msbuild/developerpacks で .NET Framework Developer Pack をダウンロードできます。」と表示されていたので、記載されたurlに飛んで.Net Framework Developer Packをダウンロードしました。バージョンが4.8っぽいんですが、上記の4.0が見当たらないのでとりあえず最新版を入れました。

再起動したらたいてい何とかなると聞いたことがあるので、何か入れるたびに再起動して動作確認していましたが、エラーは変わらずでした。

https://kivy.org/doc/stable/gettingstarted/installation.html ←kivyのインストールに当たって、ここにあるコードは全部やってみましたが、仮想環境とか全然詳しくないのでよくわかっていません。ただkivy自体はインストールできていると思います。

pip install docutils pygments pypiwin32 kivy.deps.sdl2
pip install kivy.deps.glew
pip install kivy.deps.gstreamer(追記)
pip install kivy_examples
python -m pip install --upgrade pip wheel setuptools
は試しましたが、それでもうまくいきませんでした。


### 補足情報（FW/ツールのバージョンなど）

python3.9
visual studio 2019
足りない情報があったら教えてください。

python: kivy 動かしても表示されない！

#環境
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) で参照されました。

３件の未解決の外部参照

SDL2 (Simple DirectMedia Layer2)