int/enum vs virtual function when describing a data to be handled - c++

Question

I am new to programming and encounter a question that need your experience:
I have a list of data. Each data has a format.
I have a class Builder which scan the data list and build a data tree according to their format.
As far as I can figure out, there are two ways to accomplish this:
1. Bind each data with an int/enum value to describe what it is, and the Builder can examine the int/enum value to decide which function should be used to handle token.
2. Bind each data with an virtual function which implements an interface, and call the virtual function to handle the data.
It sounds like the 2nd method is better. However, I also encounter some issues with it:
1. Is it okay to embedded the code to handle data into a data? If someday I need to modify the Builder class, I may have to modify each data class?
2. In some scenarios I need two data to cooperator together, it is hard to do this in method 2.
Could you kindly guide me which one is better?
Here are some example code:
Method 1:
struct FormatedData
{
std::string data;
int format;
};
class Builder
{
public:
void build(std::list<FormatedData> *data_list)
{
for (auto it : *data_list)
{
switch (it.format)
{
case:
do something;
break;
default:
do something;
break;
}
}
}
};
Method 2:
class Builder;
struct IIterface
{
virtual void dosomething(Builder*) = 0;
};
class FormatedData :public IIterface
{
std::string data;
int format;
void dosomething(Builder*) override
{
....
}
};
class Builder
{
public:
void build(std::list<IIterface*> *data_list)
{
for (auto it : *data_list)
{
it->dosomething(this);
}
}
};

Answer 1

Method 2 is better. Some comments:
1) all behavior for handling the data should be encapsulated in a class for handling the data. there should be no conditional statements which depend on types of data in the managing classes.
2) use factory pattern for creating new objects without changing the previously defined classes: