Инициализация. - C/C++

L>Я в общем на этом A() + почленная инициализация и не настаивал, можно же как было упомянуто, унаследоваться и запаять параметризованный конструктор, медленнее точно небылобы + почти не зависит от оптимизатора...

Оба приведенных ниже варианта зависят от встройки, так что "почти не зависит" неверное утверждение.

А так, варианты:

inline A make_A(int a, int b)
{
    A temp = {a, b};
    return temp;    
}

struct initializer_A : A
{
    initializer_A(int a, int b) /*: A() */
    {
        this->a = a;
        this->b = b;
    }    
};

конечно же, должны быть равнозначны по скорости. Но, оговорюсь, надо профилировать, чтобы сделать окончательный вывод.

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

Думаю это не катит... человек же что говорит "чтобы сначала не работал конструктор по умолчанию" — видимо скорость критична!!!

"Это как же, вашу мать!
Извиняюсь, понимать?" (с) ...

Все это, конечно, хорошо. Я про make_a и наследование. А если я работаю со стандартными структурами (например что-то из boost) и таких структур/ситуаций довольно много. Что же мне, от каждой наследоваться?

Меня вообще скорее интересовало не быстродействие а const о котором я упоминал

. И вот мне показалось что вроде это весьма типичная ситуация и должны быть механизмы, позволяющие решать мою проблему без введения новых сущностей(классов, функций). Сам я их на вскидку не придумал. Но видимо их и нет…

Здравствуйте, SergeyBi, Вы писали:

А чем вас не устраивает так:

struct A
{
    int a;
    int b;
};

class B
{
    A a;
public:
    B(int sa,int sb)
    {
        a.a=sa;
        a.b=sb;
    }
};

Тест:

int main()
{
    const B b(1,2);
}

Все работает как ожидалось и с модификатором const. (VC 8.0)

Здравствуйте, Анатолий Широков, Вы писали:

L>>Я в общем на этом A() + почленная инициализация и не настаивал, можно же как было упомянуто, унаследоваться и запаять параметризованный конструктор, медленнее точно небылобы + почти не зависит от оптимизатора...

АШ>Оба приведенных ниже варианта зависят от встройки, так что "почти не зависит" неверное утверждение.

АШ>А так, варианты:

АШ>

АШ>inline A make_A(int a, int b)
АШ>{
АШ>    A temp = {a, b};
АШ>    return temp;    
АШ>}
АШ>

АШ>и

АШ>

АШ>struct initializer_A : A
АШ>{
АШ>    initializer_A(int a, int b) /*: A() */
АШ>    {
        this->>a = a;
        this->>b = b;
АШ>    }    
АШ>};
АШ>

АШ>конечно же, должны быть равнозначны по скорости. Но, оговорюсь, надо профилировать, чтобы сделать окончательный вывод.

АШ>А теперь, не будем показывать пальцами, но именно в Вашем решение с наследованием вызывается конструктор по умолчанию, хотя не далее как в 13:04 Вы ревностно к этому самому вызову относились (хотя его и не было):
АШ>

АШ>Думаю это не катит... человек же что говорит "чтобы сначала не работал конструктор по умолчанию" — видимо скорость критична!!!

АШ>"Это как же, вашу мать!
АШ>Извиняюсь, понимать?" (с) ...

Совсем я на этой работе опух!!! Виноватая я..... да ссучара вызывается

"Признаю свою вину
меру степень глубуну..." (с) ...

Здравствуйте, _nn_, Вы писали:

__>Здравствуйте, SergeyBi, Вы писали:

__>А чем вас не устраивает так:
__>

__>struct A
__>{
__>    int a;
__>    int b;
__>};

__>class B
__>{
__>    A a;
__>public:
__>    B(int sa,int sb)
__>    {
__>        a.a=sa;
__>        a.b=sb;
__>    }
__>};
__>

__>Тест:
__>

__>int main()
__>{
__>    const B b(1,2);
__>}
__>

__>Все работает как ожидалось и с модификатором const. (VC 8.0)

как уже было сказано, нас не устраивает это тем, что хотим вот так

struct A
{
   int a;
   int b;
};

class B
{
   const A a;
};

Здравствуйте, Lapulya, Вы писали:

L>как уже было сказано, нас не устраивает это тем, что хотим вот так

L>

L>struct A
L>{
L>   int a;
L>   int b;
L>};

L>class B
L>{
L>   const A a;
L>};
L>

Ой, я const не туда поставил

Ну тогда кроме функции действительно нет ничего лучше.
Можно это улучшить, сделав в виде макроса если таких структур много.

__>Ну тогда кроме функции действительно нет ничего лучше.
__>Можно это улучшить, сделав в виде макроса если таких структур много.

Ага, что-то в этом роде выйдет:

template<typename T, typename P1>
T initializer(P1 p1)
{
    T tmp = {p1};
    return tmp;
}

template<typename T, typename P1, typename P2>
T initializer(P1 p1, P2 p2)
{
    T tmp = {p1, p2};
    return tmp;
}

template<typename T, typename P1, typename P2, typename P3>
T initializer(P1 p1, P2 p2, P3 p3)
{
    T tmp = {p1, p2, p3};
    return tmp;
}

struct foo {int a; const char *b;};
struct boo {int a; double b;};

struct B 
{
    B() : f(initializer<foo>(1, "test")), b(initializer<boo>(10, 1))
    {
    }
    foo f;
    boo b;
};

Здравствуйте, SergeyBi, Вы писали:

SB>Все это, конечно, хорошо. Я про make_a и наследование. А если я работаю со стандартными структурами (например что-то из boost) и таких структур/ситуаций довольно много. Что же мне, от каждой наследоваться?

Меня вообще скорее интересовало не быстродействие а const о котором я упоминал

А как тебе такое решение: http://www.rsdn.ru/Forum/Message.aspx?mid=811923&only=1 ?

Здравствуйте, Анатолий Широков, Вы писали:

__>>Ну тогда кроме функции действительно нет ничего лучше.
__>>Можно это улучшить, сделав в виде макроса если таких структур много.

АШ>Ага, что-то в этом роде выйдет:

АШ>

АШ>template<typename T, typename P1>
АШ>T initializer(P1 p1)
АШ>{
АШ>    T tmp = {p1};
АШ>    return tmp;
АШ>}

АШ>template<typename T, typename P1, typename P2>
АШ>T initializer(P1 p1, P2 p2)
АШ>{
АШ>    T tmp = {p1, p2};
АШ>    return tmp;
АШ>}

АШ>template<typename T, typename P1, typename P2, typename P3>
АШ>T initializer(P1 p1, P2 p2, P3 p3)
АШ>{
АШ>    T tmp = {p1, p2, p3};
АШ>    return tmp;
АШ>}

АШ>struct foo {int a; const char *b;};
АШ>struct boo {int a; double b;};

АШ>struct B 
АШ>{
АШ>    B() : f(initializer<foo>(1, "test")), b(initializer<boo>(10, 1))
АШ>    {
АШ>    }
АШ>    foo f;
АШ>    boo b;
АШ>};
АШ>

Вот если добавить inline перед этим то будет вообще счастье =)

__>Вот если добавить inline перед этим то будет вообще счастье =)

Эх, поторопился. Конечно, там inline, куда же без него

АШ>А как тебе такое решение: http://www.rsdn.ru/Forum/Message.aspx?mid=811923&only=1 ?

Да, пожалуй, выход найден

Жаль все же что нет средств языка.

Здравствуйте, Анатолий Широков, Вы писали:

__>>Вот если добавить inline перед этим то будет вообще счастье =)

АШ>Эх, поторопился. Конечно, там inline, куда же без него

Можно еще и const добавить, не помешает

template<typename T, typename P1>
inline const T initializer(P1 p1)
{
    T tmp = {p1};
    return tmp;
}

Lapulya:

> Ну тут я и не спорю

у меня сомнения по поводу этого
>
>

> inline A make_A(int a, int b)
> {
>    A temp = {a, b};
>    return temp;
> }
>
> SomeClass::SomeClass():
>    a(make_A(0, 10))
> {
> }
>

Компилятор вполне может в данном случае обойтись без создания временного объекта. Даже без встраивания функции make_A. Это называется NRVO (Named Return Value Optimization). Специально для поддержания этого и аналогичных случаев в стандарте есть указание что конструктор копирования может не быть вызван.

Posted via RSDN NNTP Server 1.9 gamma

	От:	Анатолий Широков
	Дата:	16.09.04 12:50
	Оценка:	+1

	От:	SergeyBi
	Дата:	16.09.04 13:29
	Оценка:

От:	_nn_	www.nemerleweb.com
Дата:	16.09.04 13:37
Оценка:

	От:	Lapulya
	Дата:	16.09.04 14:00
	Оценка:

	От:	Lapulya
	Дата:	16.09.04 14:03
	Оценка:

	От:	Павел Кузнецов
	Дата:	23.09.04 22:40
	Оценка: