Обработка класса с длинным списком инициализации и несколькими конструкторами?

Do you know how many fields should be present per line? If so, I'd read the first few lines of the file and check based on that.

In my experience, "normal" data quite often contains commas but rarely contains tab characters. This would suggest that you should check for a consistent number of tabs in the first few lines, and go with that choice as a preferred guess. Of course, it depends on exactly what data you've got.

Ultimately, it would be quite possible to have a file which is completely valid for both formats - so you can't make it absolutely foolproof. It'll have to be a "best effort" job.

Вы можете сделать это с выходной буферизацией , но может быть лучше использовать один из многих шаблонизаторов.

Так как кажется, что вы отправляете свои PDF-файлы как «встроенные», а не «вложения», вы можете поместить URL-адрес PDF-файла в динамически созданный Iframe, а затем прикрепить этот Iframe к наложение. Это будет работать.

-JP

Вы можете показать им результаты в окне предварительного просмотра - подобно тому, как это делает Excel. Довольно ясно, когда в этом случае используется неправильный разделитель. Затем вы можете разрешить им выбирать диапазон разделителей и обновлять предварительный просмотр в реальном времени.

Затем вы можете просто сделать простое предположение о том, с чего начинать разделитель (например, сначала стоит запятая или табуляция).

Сначала возьмите любые книги по sql из Бена Форты . Если у вас есть базовые основы, вы можете приступить к пониманию библиотек, блоков и других структур. В вашей карьере вам очень поможет понимание баз данных.

Да, это возможно.
For simplicity I'll pretend that the original code is:

class Foo {
public:
    Foo() : a(0), b(1), x() { }
    Foo(int x) : a(0), b(1), x(x) { }

    int get_a() const { return a; }
    int get_b() const { return b; }
    int get_x() const { return x; }
private:
    int a, b, x;
};

The refactored code, then, is:

class Foo {
public:
    Foo() : x() { }
    Foo(int x) : x(x) { }

    int get_a() const { return common.a; }
    int get_b() const { return common.b; }
    int get_x() const { return x; }
private:
    struct Common {
        Common() : a(0), b(1) { }
        int a, b;
    } common;
    int x;
};

Boost::Parameter makes it easy to implement Named Parameter Idiom. Check out this thread on SO. This may not be exactly what you need, but provides for some flexibility when you want to forward calls to the default ctor.

You can share their common code in a private init() member function.

Example:

class Object
{
 public:
   Object(const string &Name);
   Object(const string &Name, const string &path);
   ...
 private:
   void init();
 };

 Object::Object(const string &Name)
 {
   init();
   ...
 }

 Object::Object(const string &Name, const string &path)
 {
   init();
   ...
 }

 void Object::init()
 {
//intialization stuff
   ...
 } 

First of all, you'll have memory leaks if you don't implement deletion of the allocated objects in the destructor. So you should define your destructor and delete the objects there.

If you really need to dynamically allocate the members (I don't recommended if this class owns the data member object), you can have a private method doing all the initialization and you can call that method from your constructors.

Not to do with constructors, but why do you think you have to create all those sub-objects dynamically with new? This is not a good idea - you should avoid dynamic creation wherever possible. Don't make all those members pointers - make them actual objects.

Object (const string &Name = "", const string &path = "", const bool loadMetadata = false);

Это не решит всех ваших проблем (в частности, нет способа представить конструктор с помощью Name и loadMetaData ), но это по крайней мере свернет некоторые конструкторы в один.

Я начну с того, что скажу, что (очевидно) не знаю деталей вашей системы или ограничений, которые привели к вашим проектным решениям.

При этом хорошее практическое правило состоит в том, что когда класс начинает становиться невыносимым - примерно в то время, когда вы начинаете задавать вопросы о том, как с ним справляться :) - возможно, пришло время реорганизовать этот класс на пару меньших подклассы.

Помните, что класс должен делать одну вещь очень хорошо . Если у вас появляются большие классы, которые пытаются делать слишком много вещей, вы отдаляетесь от хорошего объектно-ориентированного дизайна.

Я бы использовал разные фабричные методы (статические методы), которые возвращали бы умный ptr вашему классу. Имена фабричных методов также помогут документировать, ПОЧЕМУ вам нужны все различные параметры.

Вам действительно нужно 5 разных конструкторов?

Очень часто, если вам нужны конвертируемые конструкторы, вам также не нужен конструктор по умолчанию.

Все остальные ваши конструкторы принимают просто разные комбинации тоже самое. Возможно, было бы лучше иметь только один конструктор, который принимает все параметры, с опцией для каждого параметра, которая указывает на желание вызвать какое-то значение по умолчанию для этого параметра.

Например:

class Object
{
  Object (const string *Name, // can be NULL
    const string *path, // can be NULL 
    const bool loadMetadata);

};

Просто поместите список инициализатора в MACRO и покончите с этим.