Инициализация полей константы C++ после конструктора

Question

Я хочу создать неизменяемую структуру данных, которая, скажем, может быть инициализирована из файла.

class Image { 
public: 
    const int width,height; 
    Image(const char *filename) { 
    MetaData md((readDataFromFile(filename))); 
    width = md.width(); // Error! width is const 
    height = md.height(); // Error! height is const 
    } 
}; 

Что я могу сделать, чтобы решить эту проблему является

class Image { 
    MetaData md; 
public: 
    const int width,height; 
    Image(const char *filename): 
    md(readDataFromFile(filename)), 
    width(md.width()),height(md.height()) {} 
}; 

Однако

1. Это заставляет меня спасти MetaData как поле в моем объекте. Который я не всегда хочу.
2. Иногда логика в конструктор является гораздо более сложным, чем одну операцию чтения (например, обработка ошибок может занять несколько строк)

Таким образом, единственное решение, которое я думал вдоль линий

class A { 
    int stub; 
    int init(){/* constructor logic goes here */} 
    A():stub(init)/*now initialize all the const fields you wish 
    after the constructor ran */{} 
}; 

Есть ли идея? (В Java вы можете инициализировать final s в конструкторе).

Answer 1

Вы можете откинуть константность в конструкторе:

class Image { 
public: 
    const int width,height; 
    Image(const char *filename) : width(0), height(0) { 
     MetaData md(readDataFromFile(filename)); 

     int* widthModifier = const_cast<int*>(&width); 
     int* heightModifier = const_cast<int*>(&height); 
     cout << "Initial width " << width << "\n"; 
     cout << "Initial height " << height << "\n"; 
     *widthModifier = md.GetWidth(); 
     *heightModifier = md.GetHeight(); 
     cout << "After const to the cleaners " << width << "\n"; 
     cout << "After const to the cleaners " << height << "\n"; 
    } 
}; 

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

Answer 2

Вы могли двигаться width и height в один тип и переместить код инициализации в хелперов инициализации функции:

// header: 
struct Size { 
    int width, height; 
    Size(int w, int h) : width(w), height(h) {} 
}; 

class Image { 
    const Size size; // public data members are usually discouraged 
public: 
    Image(const char *filename); 
}; 

// implementation: 
namespace { 
    Size init_helper(const char* filename) { 
     MetaData md((readDataFromFile(filename))); 
     return Size(md.width(), md.height()); 
    } 
} 

Image::Image(const char* filename) : size(init_helper(filename)) {} 

Answer 3

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

Ergo, Все элементы инициализируются в (подразумеваемом, если не указано явно) списке инициализации. Ясно, что в списке должны быть инициализированы переменные const, потому что, как только вы входите в тело, они уже предполагается инициализироваться; вы просто пытаетесь их назначить.

Как правило, у вас нет const пользователей. Если вы хотите, чтобы эти члены были неизменными, просто не предоставляйте публичный доступ к ним, которые могли бы их изменить. (Кроме того, наличие const членов делает ваш класс неприемлемым, как правило, излишне.) Переход по этому маршруту легко устраняет вашу проблему, так как вы просто присваиваете им значения в теле конструктора, как хотите.

метод, чтобы делать то, что вы хотите, сохраняя при этом const может быть:

class ImageBase 
{ 
public: 
    const int width, height; 

protected: 
    ImageBase(const MetaData& md) : 
    width(md.width()), 
    height(md.height()) 
    {} 

    // not meant to be public to users of Image 
    ~ImageBase(void) {} 
}; 

class Image : public ImageBase 
{ 
public: 
    Image(const char* filename) : // v temporary! 
    ImageBase(MetaData(readDataFromFile(filename))) 
    {} 
}; 

Я не думаю, что этот маршрут стоит.

Answer 4

Вы должны добавить встроенные getters для ширины и высоты вместо переменных public const member. Компилятор сделает это решение так же быстро, как оригинальная попытка.

class Image { 
public: 
    Image(const char *filename){ // No change here 
    MetaData md((readDataFromFile(filename))); 
    width = md.width(); 
    height = md.height(); 
    } 
    int GetWidth() const { return width; } 
    int GetHeight() const { return height; } 
private: 
    int width,height; 
}; 

P.S .: Раньше я писал личные вещи в конце, потому что они менее важны для пользователя этого класса.

Answer 5

Как насчет передачи MetaData в качестве аргумента конструктору. Это дает много преимуществ:

a) Интерфейс конструктора дает понять о зависимости от MetaData. б) Это облегчает тестирование класса изображений с различными типами метаданных (подклассы)

Так что, я бы, наверное, предположить, похож на следующее:

struct MD{ 
    int f(){return 0;} 
}; 

struct A{ 
    A(MD &r) : m(r.f()){} 
    int const m; 
}; 

int main(){} 

Answer 6

Я хотел бы использовать статический метод:

class Image { 
public: 
    static Image* createFromFile(const std::string& filename) { 
     //read height, width... 
     return new Image(width, height); 
    } 

    //ctor etc... 
} 

Answer 7

Вы можете просто использовать NamedConstructor идиомы здесь:

class Image 
{ 
public: 
    static Image FromFile(char const* fileName) 
    { 
    MetaData md(filename); 
    return Image(md.height(), md.width()); 
    } 

private: 
    Image(int h, int w): mHeight(h), mWidth(w) {} 

    int const mHeight, mWidth; 
}; 

Одним из главных преимуществ Named Constructors является их очевидность: имя указывает, что вы создаете свой объект из файла. Конечно, это несколько более подробно:

Image i = Image::FromFile("foo.png"); 

Но это меня никогда не беспокоило.

Answer 8

Если это C++ 0x, я бы рекомендовал это (делегирование конструкторов):

class Image 
{ 
    public: 

    const int width, height; 

    Image(const char* filename) : Image(readDataFromFile(filename)) { } 
    Image(const MetaData& md) : width(md.width()), height(md.height()) { } 
}; 

Answer 9

class A 
{ 
public: 
    int weight,height; 

public: 
    A():weight(0),height(0) 
    { 
    } 

    A(const int& weight1,const int& height1):weight(weight1),height(height1) 
    { 
     cout<<"Inside"<<"\n"; 
    } 
}; 

static A obj_1; 

class Test 
{ 
    const int height,weight; 

public: 
    Test(A& obj = obj_1):height(obj.height),weight(obj.weight) 
    { 
    } 

    int getWeight() 
    { 
     return weight; 
    } 

    int getHeight() 
    { 
     return height; 
    } 
}; 

int main() 
{ 
    Test obj; 

    cout<<obj.getWeight()<<"\n"; 

    cout<<obj.getHeight()<<"\n"; 

    A obj1(1,2); 

    Test obj2(obj1); 

    cout<<obj2.getWeight()<<"\n"; 

    cout<<obj2.getHeight()<<"\n"; 

    return 0; 
} 

Насколько я понимаю, я думаю, что этот механизм будет работать.

Answer 10

Это один из моих наименее любимых аспектов C++ по сравнению с Java. Я буду использовать пример, над которым работал, когда мне нужно было решить эту проблему.

Далее следует эквивалент метода readObject. Он десериализует видео-ключ из предоставленного пути к файлу.

#include <fstream> 
#include <sstream> 
#include <boost/archive/binary_iarchive.hpp> 
#include <boost/archive/binary_oarchive.hpp> 

using namespace std; 
using namespace boost::filesystem; 
using namespace boost::archive; 

class VideoKey 
{ 
    private: 
    const string source; 
    const double fps; 
    const double keyFPS; 
    const int numFrames; 
    const int width; 
    const int height; 
    const size_t numKeyFrames; 
    //Add a private constructor that takes in all the fields 
    VideoKey(const string& source, 
     const double fps, 
     const double keyFPS, 
     const int numFrames, 
     const int width, 
     const int height, 
     const size_t numKeyFrames) 
    //Use an initializer list here 
    : source(source), fps(fps), keyFPS(keyFPS), numFrames(numFrames), width(width), height(height), numKeyFrames(numKeyFrames) 
    { 
     //Nothing inside this constructor 
    } 
    public: 
    //Then create a public static initializer method that takes in 
    //the source from which all the fields are derived 
    //It will extract all the fields and feed them to the private constructor 
    //It will then return the constructed object 
    //None of your fields are exposed and they are all const. 
    const static VideoKey create(const path& signaturePath) 
    { 
     const path keyPath = getKeyPath(signaturePath); 
     ifstream inputStream; 
     inputStream.open(keyPath.c_str(), ios::binary | ios::in); 
     if (!inputStream.is_open()) 
     { 
     stringstream errorStream; 
     errorStream << "Unable to open video key for reading: " << keyPath; 
     throw exception(errorStream.str().c_str()); 
     } 
     string source; 
     double fps; 
     double keyFPS; 
     int numFrames; 
     int width; 
     int height; 
     size_t numKeyFrames; 
     { 
     binary_iarchive inputArchive(inputStream); 
     inputArchive & source; 
     inputArchive & fps; 
     inputArchive & keyFPS; 
     inputArchive & numFrames; 
     inputArchive & width; 
     inputArchive & height; 
     inputArchive & numKeyFrames; 
     } 
     inputStream.close(); 
     //Finally, call your private constructor and return 
     return VideoKey(source, fps, keyFPS, numFrames, width, height, numKeyFrames); 
    }