C++ 适当地放置「；toCSV"；函数：在每个对象中，还是在泛型类中？

有一组classA对象，包含多个数据字段，在每个classA对象中，有一组classB对象，包含其他数据字段

在某个时候，我想生成一个CSV文件

我的初始方法是在classA和classB中实现.toCSV（），并在main.cpp中执行以下操作：

string completecsv;
foreach(classA ca, setOfClassA)
    completecsv.append(ca.toCSV());

和内部classA.toCSV（）

最后在classB.toCSV（）中

现在，我的另一种方法是创建一个名为OutputManager的类，负责CSV生成的所有工作，使MVC模式更加清晰地分开

对这两种方法有什么想法

---

非常感谢。

如果有许多

classA

和

classB

属性可以包含在报表中，而不管报表格式（CSV、XML、Json等），那么听起来

classA

和

classB

实际上是没有太多逻辑的数据类

如果是这样的话，我会将报表生成与它们分开，以便在需要时可以使用其他输出格式轻松地扩展报表机制

为了适应分层输出格式（如XML或Json），让从中读取属性的类型也公开“children”属性可能是有意义的，这样就可以循环并递归地应用它

interface IOutputtable
{
    NameValueCollection Items { get; }
    IEnumerable<IOutputtable> Children { get; }
}

class A : IOutputtable
{
    private int _baz;

    public NameValueCollection Items {
        get {
            return new NameValueCollection() {
                { "baz", _baz.ToString() }
            };
        }
    }

    public IEnumerable<IOutputtable> Children {
        get {
            return Enumerable.Empty<IOutputtable>();
        }
    }
}

class B : IOutputtable
{
    private int _foo;
    private string _bar;
    private List<A> _as = new List<A>();

    public NameValueCollection Items {
        get {
            return new NameValueCollection() {
                { "foo", _foo.ToString() },
                { "bar", _bar }
            };
        }
    }

    IEnumerable<IOutputtable> Children {
        get { return _as; }
    }
}

对于获得输出的每个类型，它都可以公开其“可输出”数据的名称值集合，

OutputManager

然后选择如何处理这些数据

类似这样的情况，

OutputManager

将获取“根”

IOutputtable

（

classB

），然后循环其名称值，然后递归地对其子级执行相同的操作

interface IOutputtable
{
    NameValueCollection Items { get; }
    IEnumerable<IOutputtable> Children { get; }
}

class A : IOutputtable
{
    private int _baz;

    public NameValueCollection Items {
        get {
            return new NameValueCollection() {
                { "baz", _baz.ToString() }
            };
        }
    }

    public IEnumerable<IOutputtable> Children {
        get {
            return Enumerable.Empty<IOutputtable>();
        }
    }
}

class B : IOutputtable
{
    private int _foo;
    private string _bar;
    private List<A> _as = new List<A>();

    public NameValueCollection Items {
        get {
            return new NameValueCollection() {
                { "foo", _foo.ToString() },
                { "bar", _bar }
            };
        }
    }

    IEnumerable<IOutputtable> Children {
        get { return _as; }
    }
}

接口IOutputtable
{
NameValueCollection项{get；}
IEnumerable子项{get；}
}
A级：不合格品
{
私人国际巴兹；
公共名称价值收集项目{
得到{
返回新的NameValueCollection（）{
{“baz”，_baz.ToString（）}
};
}
}
可数儿童的公共教育{
得到{
返回可枚举的.Empty（）；
}
}
}
B类：不合格品
{
私营机构国际办事处;；
私人字符串(u bar),；
私有列表_as=新列表（）；
公共名称价值收集项目{
得到{
返回新的NameValueCollection（）{
{“foo”，_foo.ToString（）}，
{“bar”，_bar}
};
}
}
数不清的孩子{
获取{return\u as；}
}
}

我完全同意所作的陈述，当将来可能需要不同的序列化时，将输出函数分开会有所帮助。但是，我真的不喜欢用C++回答问题（我只能猜测）C的例子代码…哈哈！我刚才在别处回答了另一个C#问题，没意识到这不是一个：）-现在修好

interface IOutputtable
{
    NameValueCollection Items { get; }
    IEnumerable<IOutputtable> Children { get; }
}

class A : IOutputtable
{
    private int _baz;

    public NameValueCollection Items {
        get {
            return new NameValueCollection() {
                { "baz", _baz.ToString() }
            };
        }
    }

    public IEnumerable<IOutputtable> Children {
        get {
            return Enumerable.Empty<IOutputtable>();
        }
    }
}

class B : IOutputtable
{
    private int _foo;
    private string _bar;
    private List<A> _as = new List<A>();

    public NameValueCollection Items {
        get {
            return new NameValueCollection() {
                { "foo", _foo.ToString() },
                { "bar", _bar }
            };
        }
    }

    IEnumerable<IOutputtable> Children {
        get { return _as; }
    }
}