If you wish to create a really flexible and extensible system you could tackle this by having entities and properties as different classes. Entities would be objects in your game such as the player, monsters, potions, weapons etc, and properties are things which describe the state of an entity such as its physical strength value, its endurance value, whether the entity is resistant to fire, whether the entity is consumable or equipable, etc. The entity base class would contain an enum describing its entity type so other entities and properties know what it is, and a list or vector of properties which apply to that entity. Similarly the property base class would contain an enum describing its property type, and the derived property class could contain any additional data needed for that property. Entities can then interact with each other appropriately by adding properties to each other, scanning for the existance of propeties to see if they can undergoe appropriate interactions with each other, and altering the values of existing properties to effect each other.

Some basic rough psuedo code as an example of how you could begin to build and use such a system to give you an idea:


// base classes
class Property
{
Entity* m_pOwner;
PropertyType m_myType;
void Update();
};

class Entity
{
EntityType m_myType;
vector<Property*> m_myProperties;

void ApplyToEntity(Entity* pEntity);
void UpdateProperties();
};


// some derived classes
class HealthProperty : public Property
{
float m_value;

HealthProperty(float value)
{
m_myType = PropertyType_Health;
m_value = value;
}
};

class FlamableProperty : public Property
{
FlamableProperty (float value)
{
m_myType = PropertyType_Flamable;
}
};

class OnFireProperty : public Property
{
float m_dpu; // damager per update
OnFireProperty (float dpu)
{
m_dpu = dpu;
m_myType = PropertyType_Flamable;
}

Update()
{
if(m_pOwner->HasProperty(PropertyType_Health))
{
m_pOwner->GetProperty(PropertyType_Health)->m_value -= m_dpu;
}
}
};

class Monster : public Entity
{
Monster()
{
m_myType = EntityType_Monster;
m_myProperties.push_back(new HealthProperty(100));
m_myProperties.push_back(new FlamableProperty());
}
};

class FireBomb: public Entity
{
FireBomb()
{
m_myType = EntityType_FireBomb;
}

void ApplyToEntity(Entity* pEntity)
{
// apply damage from the initial explosion
if(pEntity->HasProperty(PropertyType_Health))
{
pEntity->GetProperty(PropertyType_Health)->m_value -= 10;
}

// set entity on fire if it is flamable
if(pEntity->HasProperty(PropertyType_Flamable))
{
pEntity->AddProperty(new OnFireProperty(2));
}
}
};


Its not a perfect example but hopefully you get the idea and can see the scope and flexibility that a system like that can give you. Might be worth considering if you intend on making a large roguelike game or something like that.

What you could do is have a delta list associated with each stat. These lists would contain all the bonuses and penalties currently applied to that stat. Equipping an item would a bonus to that list, while drinking a potion would add a temporary bonus to the list. The advantage of this is it easily ties in with your ui if you want to show the player the breakdown of a stats current derived value. And if you want add negative affects from attacks or traps later on you already have a frame work in place to do that.