C++享元模式与内存优化

C++享元模式与内存优化

享元模式通过共享细粒度对象减少内存使用。它将对象状态分为内部状态（共享）和外部状态（上下文相关），适合大量相似对象的场景。

享元工厂管理共享对象池。

#include
#include
#include
#include
#include

enum class FontType { SERIF, SANS_SERIF, MONO };

struct CharProperty {
char character;
FontType font;
int size;
bool bold;
bool italic;
};

class Glyph {
char character_;
FontType font_;
int size_;
bool bold_;
bool italic_;

public:
Glyph(char c, FontType f, int s, bool b, bool i)
: character_(c), font_(f), size_(s), bold_(b), italic_(i) {}

void render(int x, int y) const {
std::cout << "Glyph '" << character_ << "' at (" << x << "," << y << ")"
<< " font=" << static_cast(font_)
<< " size=" << size_
<< " bold=" << bold_
<< " italic=" << italic_ << "\n";
}

bool operator==(const Glyph& other) const {
return character_ == other.character_ && font_ == other.font_
&& size_ == other.size_ && bold_ == other.bold_
&& italic_ == other.italic_;
}
};

struct GlyphHash {
size_t operator()(const Glyph& g) const {
size_t h1 = std::hash{}(g.character_);
size_t h2 = std::hash{}(static_cast(g.font_));
size_t h3 = std::hash{}(g.size_);
size_t h4 = std::hash{}(g.bold_);
size_t h5 = std::hash{}(g.italic_);
return h1 ^ (h2 << 1) ^ (h3 << 2) ^ (h4 << 3) ^ (h5 << 4);
}
};

class GlyphFactory {
std::unordered_map, GlyphHash> pool_;

public:
std::shared_ptr get_glyph(char c, FontType f, int s, bool b, bool i) {
Glyph temp(c, f, s, b, i);
auto it = pool_.find(temp);
if (it != pool_.end()) {
std::cout << "Reusing glyph\n";
return it->second;
}

auto glyph = std::make_shared(c, f, s, b, i);
pool_[temp] = glyph;
std::cout << "Creating new glyph (pool size: " << pool_.size() << ")\n";
return glyph;
}

size_t pool_size() const { return pool_.size(); }
};

void flyweight_demo() {
GlyphFactory factory;

std::vector, std::pair>> document;

document.push_back({factory.get_glyph('H', FontType::SERIF, 12, true, false), {0, 0}});
document.push_back({factory.get_glyph('e', FontType::SERIF, 12, true, false), {10, 0}});
document.push_back({factory.get_glyph('l', FontType::SERIF, 12, true, false), {20, 0}});
document.push_back({factory.get_glyph('l', FontType::SERIF, 12, true, false), {30, 0}});
document.push_back({factory.get_glyph('o', FontType::SERIF, 12, true, false), {40, 0}});

std::cout << "\nRendering document:\n";
for (const auto& [glyph, pos] : document) {
glyph->render(pos.first, pos.second);
}

std::cout << "\nPool size: " << factory.pool_size() << " (5 chars, 4 unique)\n";
}

粒子系统使用享元。

class ParticleTexture {
std::string texture_name_;
int width_;
int height_;
public:
ParticleTexture(const std::string& name, int w, int h)
: texture_name_(name), width_(w), height_(h) {}

void render(int x, int y, int frame) const {
std::cout << "Render '" << texture_name_ << "' (" << width_
<< "x" << height_ << ") at (" << x << "," << y
<< ") frame=" << frame << "\n";
}
};

class ParticleTextureFactory {
std::unordered_map> textures_;
public:
std::shared_ptr get_texture(const std::string& name, int w, int h) {
auto it = textures_.find(name);
if (it != textures_.end()) return it->second;

auto tex = std::make_shared(name, w, h);
textures_[name] = tex;
return tex;
}
};

struct Particle {
int x, y, frame;
std::shared_ptr texture;

void render() const {
texture->render(x, y, frame);
}
};

void particle_demo() {
ParticleTextureFactory factory;
std::vector particles;

auto fire = factory.get_texture("fire", 32, 32);
auto smoke = factory.get_texture("smoke", 16, 16);

for (int i = 0; i < 5; ++i) {
particles.push_back({10 * i, 20 * i, i, fire});
}
for (int i = 0; i < 5; ++i) {
particles.push_back({5 * i, 15 * i, i, smoke});
}

std::cout << "5 fire + 5 smoke particles, 2 textures shared\n";
for (const auto& p : particles) p.render();
}

享元模式通过共享减少内存占用，适合大量重复对象的场景。