Russian Qt Forum

Есть класс (всего лишь пример)

C++ (Qt)
template < typename _Type, int _N >
class Point
{
    _Type m_values[ _N ];
 
    ...
};
 

Как бы его реализовать так, чтобы в коде можно было использовать в виде

C++ (Qt)
 
Point< double, 2 > point2d( 1.0, 2.0 );
Point< double, 3 > point3d( 1.0, 2.0, 3.0 );
 
...
 
Point< double, N > pointNd( 1.0, 2.0, ... , N );
 
 

ну или хотя бы в виде

C++ (Qt)
 
Point< double, 2 > point2d( Something( 1.0, 2.0 ) );
Point< double, 3 > point3d( Something( 1.0, 2.0, 3.0 ) );
 
...
 
Point< double, N > pointNd( Something( 1.0, 2.0, ... , N ) );
 
 

Т.е.,  имеется заранее известное количество аргументов конструктора, равное входящему параметру шаблона _N.

Есть решения, если не использовать вариации типа printf( fmt, ... ) и новый стандарт C++11?

С variadic template это можно было бы легко сделать.. Но это c++11 :(
 

Понимаю что это "всего лишь пример" - но как Вы запишете метод (или оператор) векторного произведения "в общем виде"? :). А point4d (часто кватернион) отличается еще больше. Др словами хотя обобщение напрашивается - "сущности" разные, возможно стоит удовлетвориться набором индивидуальных классов.

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

Нужно что-то типа такого?

http://ideone.com/yiwPkQ

Да, variadic template  как раз для этой ситуации, жаль их только недавно придумали :).

Параметр N наверняка имеет какое-то ограничение (пусть 10 или 20). Можно сделать конструктор с параметрами по умолчанию, а там сколько придет - столько и обрабатывать. Или наплодить N конструкторов на все случаи жизни, при компиляции выберется нужный. В любом случае руками придется много делать.

Еще можно подумать над вариантами со списком типов или какими-нибудь рекурсивными шаблонами. Похоже, без Александреску не обойтись :).

Да хотелось бы что-то типа такого, как в C++11.

Пока что я использую такой подход

C++ (Qt)
 
template < typename _Type, unsigned int _N >
class Point
{
...
public:
    Point ( const _Type( &values )[ N ] );
...
};
 
 

// Базовый класс, преобразующийся к _Type[ _N ]

C++ (Qt)
 
template < typename _Type, unsigned int _N >
class BasicArgs
{
public:
    typedef _Type ( Values ) [ N ];
 
protected:
    Values m_values;
 
public:
    inline BasicArgs () {}
    inline operator const Values & () const { return m_values; }
...
};
 

// Конкретный класс с дальнейшим уточнением

C++ (Qt)
 
template < typename _Type, unsigned int _N >
class Args;
 
 

// Для одного аргумента

C++ (Qt)
template < typename _Type >
class Args< _Type, 1 >
    : public BasicArgs< _Type, 1 >
{
public:
    inline Args ( const _Type & value = _Type() )
    {
        this->m_values[ 0 ] = value;
    }
};
 

// Для двух аргументов

C++ (Qt)
 
template < typename _Type >
class Args< _Type, 2 >
    : public BasicArgs< _Type, 2 >
{
public:
    inline Args (
        const _Type & value1 = _Type(),
        const _Type & value2 = _Type() )
    {
        this->m_values[ 0 ] = value1;
        this->m_values[ 1 ] = value2;
    }
};
 
 

и т.д. для любого количества, пока не надоест писать  ;D

Тогда в коде можно использовать такую запись

C++ (Qt)
 
typedef Point< double, 3 > Point3d;
typedef Vector< double, 3 > Vector3d;
typedef Args< double, 3 > Args3d;
 
Point3d p1 = Point3d( Args3d( 1.0, 2.0, 3.0 ) );
Point3d p2 = Point3d( Args3d( 4.0, 5.0, 6.0 ) );
...
 
Vector3d v1 = Vector3d( Args3d( 1.0, 1.0, 1.0 ) );
...
 
 

Лучше пока ничего не придумал.
Может у кого есть более изящное решение?

Почему бы тогда ни сделать просто: взять с++11 и не мучаться с велосипедами?


Если дизайн устраивает - то нормальный способ. Смысли - он простой. Его легко понять. Если при этом это легко использовать - то чего ещё нужно то?

А вообще, в рамках с++03 нет вариардиков, поэтому там при любой конструкции будет нечто, что будет обладать тучей конструкторов, или тучей перегрузок, или тем и тем одновременно.


Если хочется высокой гибкости, то в рамках 2003 есть несколько способов имитировать вариардики. Все они обладают разной степенью "сложности".

Как вариант вот такой дизайн самодельных кортежей:


Вся сложность шаблонов будет инкапсулирована внутри одного лишь my::tuple, который будет отвечать за хранения данных разных типов, и наполнение этим данными других объектов.

В некоторых проектах есть такие требования  :-\, старые старые IDE => старые компиляторы.

Кортежи - это, конечно, хорошо, но громоздко в использовании.
Легче тогда уж так

C++ (Qt)
 
double coords[3] = { 1.0, 2.0, 3.0 };
Point p = Point( coords );
 
 

чем

C++ (Qt)
 
my::tuple< double, double, double > t( 1.0, 2.0, 3.0 );
Point p;
t.transmit( p, &Point::setValues );
 
 

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

C++ (Qt)
double coords[3] = { 1.0, 2.0, 3.0 };
Point p = Point( coords );

А вообще в С++11 можно вот так делать :):

C++ (Qt)
typedef double Double3[3];
typedef Point< double, 3 > Point3d;
 
int main(int argc, char *argv[])
{
    ...
    Point3d p( Double3{ 1.0, 2.0, 3.0 } );
    ...
}

Если это Visual Studio, то, начиная с VS 2010, можно использовать компиляторы из других SDK. Visual Studio Platform Toolset (http://msdn.microsoft.com/en-us/library/vstudio/ff770576(v=vs.100).aspx).