Переопределение виртуальной функции в разных файлах наследственных классов

class Base
{
public:
  virtual int foo() { return 0; }
};
 
class Second: public Base
{
public:
  int foo() { return 1; }
};
 
int main()
{
  Base* b1 = new Base();
  Base* b2 = new Second();
  std::cout << b1->foo() << std::endl << b2->foo() << std::endl;
}

int foo() override

struct base { 
    int foo() const { return 123; } 
};
struct derived : base { 
    int foo() const { return 2019; } 
};
 
int main()
{
    base const& b = derived();
    std::cout << b.foo(); // prints 123
}

struct base { 
    virtual int foo() const { return 123; } 
};
struct derived : base { 
    int foo() const { return 2019; } 
};
 
int main()
{
    base const& b = derived();
    std::cout << b.foo(); // prints 2019
}

#pragma once
 
#include <SFML/Graphics.hpp>
#include <iostream>
 
class block
{
public:
    block(bool is_solid = false);
    bool getSolid();
    virtual sf::Vector2i getTexCoord();
private:
    bool is_solid;
};

#include "block.h"
 
block::block(bool is_solid)
{
    this->is_solid = is_solid;
}
 
bool block::getSolid()
{
    return is_solid;
}
 
sf::Vector2i block::getTexCoord()
{
    std::cout << "Void" << std::endl;
    return sf::Vector2i(0,0);
}

#pragma once
#include "block.h"
#include <iostream>
 
class blockFloor : public virtual block
{
public:
    blockFloor(bool is_solid) : block(is_solid) {}
    virtual sf::Vector2i getTexCoord() override;
private:
};

#include "blockFloor.h"
 
sf::Vector2i blockFloor::getTexCoord()
{
    std::cout<<"Floor"<<std::endl;
    return sf::Vector2i(1,0);
}

#include "blockMap.h"
 
blockMap::blockMap()
{
    size = sf::Vector2i(32, 32);
}
 
blockMap::blockMap(sf::Vector2i size)
{
    this->size = size;
 
    blocks.resize(size.x * size.y);
}
 
void blockMap::generate()
{
    shipAtlas.loadFromFile("textures\\shipTex.png");
    vertices.setPrimitiveType(sf::Quads);
    vertices.resize(4 * size.x * size.y);
    states.texture = &shipAtlas;
 
    float tileStep = 64;
    sf::Vector2i texCoord;
    for (int y = 0; y < size.y; y++)
    {
        for (int x = 0; x < size.x; x++)
        {
            int i = 1 + rand() % 3;
            if(i==1)
            blocks.push_back(new blockFloor(false));
            else
            blocks.push_back(new blockWall(true));
 
            texCoord = blocks[x + y * size.x].getTexCoord(); // Вот место где вызывается функция
 
            sf::Vertex* quad = &vertices[(x + y * size.x) * 4];
 
            quad[0].position = sf::Vector2f(x * blockSize, y * blockSize);
            quad[1].position = sf::Vector2f((x + 1) * blockSize, y * blockSize);
            quad[2].position = sf::Vector2f((x + 1) * blockSize, (y + 1) * blockSize);
            quad[3].position = sf::Vector2f(x * blockSize, (y + 1) * blockSize);
 
            quad[0].texCoords = sf::Vector2f((texCoord.x + 0) * tileStep, (texCoord.y + 0) * tileStep);
            quad[1].texCoords = sf::Vector2f((texCoord.x + 1) * tileStep, (texCoord.y + 0) * tileStep);
            quad[2].texCoords = sf::Vector2f((texCoord.x + 1) * tileStep, (texCoord.y + 1) * tileStep);
            quad[3].texCoords = sf::Vector2f((texCoord.x + 0) * tileStep, (texCoord.y + 1) * tileStep);
            //quad[0].color = sf::Color::Red;
            //quad[1].color = sf::Color::Blue;
            //quad[2].color = sf::Color::Yellow;
            //quad[3].color = sf::Color::Green;
        }
    }
}
 
void blockMap::draw(sf::RenderWindow& wind)
{
    wind.draw(vertices, states);
}

#pragma once
#include "block.h"
#include <iostream>
 
class blockFloor : public block
{
public:
    blockFloor(bool is_solid) : block(is_solid) {}
    sf::Vector2i getTexCoord() override;
private:
};

blocks[x + y * size.x]->getTexCoord();

std::vector<block*> blocks;

std::vector<block*> blocks;

texCoord = blocks[x + y * size.x]->getTexCoord();

if(i==1)
            blocks[x + y * size.x] = new blockFloor(false);
            else
            blocks.push_back(new blockWall(true));