std::array of objects in initializer list

[Operator S. (smkr)]

Kann man die Position eines Objektes, welches in einem std::array liegt 
seinem eigenen Konstruktor übergeben?

folgendes Problem:

//Actor.h
class Actor {
public:
    Actor(const std::string &moduleName, int baseAddress);
}

//Device.h
class Device{
public:
    Device();

private:
    std::array<Actor, 16> actorDigital;
}

//Device.cpp
Device::Device() :
  // std::array needs double {{..}} to initialize objects
  actorDigital{{   Actor("DigitalOut1"),
    Actor("DigitalOut2"),
    Actor("DigitalOut3"),
    Actor("DigitalOut4"),
    Actor("DigitalOut5"),
    Actor("DigitalOut6"),
    Actor("DigitalOut7"),
    Actor("DigitalOut8"),
    Actor("DigitalOut9"),
    Actor("DigitalOut10"),
    Actor("DigitalOut11"),
    Actor("DigitalOut12"),
    Actor("DigitalOut13"),
    Actor("DigitalOut14"),
    Actor("DigitalOut15"),
    Actor("DigitalOut16")
  }}
{
}

Zuerst hatte ich noch keine baseAddress im Actor() und habe von Hand die 
Namen vergeben, was mir eigentlich schon nicht gefiel. Nun müsste ich 
noch anhand des Index die baseAddress vergeben, dies wäre etwas in der 
Art:

address + (index * x)

Genauso könnte ich den Namen generieren lassen, ohne von Hand 
durchzuzählen, mein Ziel wäre:

Actor("DigitalOut" + to_string(index), address + (index * x) )

Gibt es einen Weg das std::array so zu initialisieren?

[Wilhelm M. (wimalopaan)]

Wenn es nur um die Nummer geht -> statische Datenmember.
Aber das ist wahrscheinlich nicht das, was Du willst.

[Operator S. (smkr)]

Kannst du mir mehr über die statischen Datenmember sagen? (Link zu 
beispiel oder so)

Würde ich stattdessen das array mit pointer füllen, hätte ich vermutlich 
so etwas gemacht:

for(unsigned int i=0; i<actorDigital.size(); ++i){
    actorDigital[i] = new Actor(("DigitalOut" + to_string(i), 0x100 + (i * 0x04) );
}

Bei dieser Lösung könnte ich aber gleich zum vector<> gehen und hätte 
das ganze sauberer gelöst.

(Das es hier im Beispiel bei 0 Anfangen würde und nicht bei 1 soll mal 
ausser acht gelassen werden, aber ich denke die Idee ist klar.)

[Oliver S. (oliverso)]

Am einfachsten in solchen Fällen ist es doch, das einfach mal 
auszuprobieren (und schön wäre es, wenn dann im Ausgangsbeitrag schon 
compilierbarerer Code gepostet wird):

#include <array>
#include <iostream>

class Actor
{
public:
  const std::string Name;
  const int index;
    Actor(const std::string &moduleName, int baseAddress) : Name(moduleName),
                                index(baseAddress)
{}
};

class Device{
public:
    Device();

public:
    int index = 0;
    const int address = 1;
    std::array<Actor, 2> actorDigital;
};

//Device.cpp
Device::Device() :
  // std::array needs double {{..}} to initialize objects
  actorDigital{   Actor("DigitalOut" + std::to_string(index), index++),
                Actor("DigitalOut" + std::to_string(index), index++)
              }
{
}

int main()
{
  Device d;
  for (const auto& a : d.actorDigital)
  {
    std::cout << a.Name << " " << a.index << std::endl;
  }
}

DigitalOut1 0
DigitalOut2 1


Oliver

[Dr. Sommer (Gast)]

Oliver S. schrieb:
> Am einfachsten in solchen Fällen ist es doch, das einfach mal
> auszuprobieren:

Das ist aber undefiniertes Verhalten , pures Glück dass es funktioniert. 
Wenn man eine Variable (hier Index) innerhalb eines Ausdrucks mehrfach 
verändert passiert etwas Compiler spezifisches...

[Wilhelm M. (wimalopaan)]

Dachte etwa an:

#include <array>
#include <string>
#include <iostream>

class Actor
{
public:
    Actor(const std::string& baseName = "bla") : name(baseName + std::to_string(numberOfActors++)) {}
//private:
    static size_t numberOfActors;
    std::string name;
};
size_t Actor::numberOfActors = 0;

std::ostream& operator<<(std::ostream& o, const Actor& a) {
    return o << a.name;
}

int main()
{
    std::array<Actor, 3> actors;
    
    for(auto& a: actors) {
        std::cout << a << std::endl;
    }
        
}

[Wilhelm M. (wimalopaan)]

Oder so:

class Actor
{
public:
    friend std::ostream& operator<<(std::ostream& o, const Actor& a);
    Actor(const std::string& baseName = "bla") : name(baseName + std::to_string(numberOfActors)), 
        number(numberOfActors++) {}
private:
    static size_t numberOfActors;
    std::string name;
    const size_t number;
};
size_t Actor::numberOfActors = 0;

std::ostream& operator<<(std::ostream& o, const Actor& a) {
    return o << a.name;
}

int main()
{
    std::array<Actor, 3> actors;
    
    for(const auto& a: actors) {
        std::cout << a << std::endl;
    }
}

[Wilhelm M. (wimalopaan)]

Wobei das Generieren des Namens / Nummer sollte man ggf. in eine Factory 
refaktorieren ...

[Wilhelm M. (wimalopaan)]

Operator S. schrieb:

> Bei dieser Lösung könnte ich aber gleich zum vector<> gehen und hätte
> das ganze sauberer gelöst.

Ja, warum nicht? Dann vllt auf die heap-allocation verzichten?

Die Frage ist: hast Du Allocator auf Deiner Plattform? Schaut aber so 
aus, als ob Du nicht auf BareMetal bist ...

[Operator S. (smkr)]

Danke für Antworten, es scheint also keine direkte Lösung über 
std::array zu geben?

Beitrag "Re: std::array of objects in initializer list"

An dieser Lösung fehlt mir der boundary check, der ja mit array möglich 
wäre. Ebenso muss wieder viel geschrieben werden, wollte das eigentlich 
vermeiden und nur eine "vorlage" schreiben, die der Compiler richtig 
generiert.

Beitrag "Re: std::array of objects in initializer list"

Dieser Ansatz habe ich auch schon angedacht, aber wenn ich ein zweites 
array ala

std::array<Actor, 3> actorsDigital;
std::array<Actor, 3> actorsAnalog;

habe, funktioniert es wieder nicht. Der index müsste auf das array 
bezogen sein und nicht auf die Objekte.

std::array wollte ich einsetzen da ich eine feste Grösse habe, aber 
nicht auf Actor actor[16] setzen wollte, alleine schon wegen 
range-based-loops. Irgendwie bin ich aber nie zufrieden mit dem 
std::array, so dass ich doch raw-arrays oder std::vector einsetze - 
schade.


Bezüglich dem compilierbaren code: Wie so oft ist die eigentliche Klasse 
viel grösser und einige Namen mussten firmenbezogen obfuscated werden. 
Werde mir aber in Zukunft mehr mühe geben.

[Torsten R. (Firma: Torrox.de) (torstenrobitzki)]

Operator S. schrieb:
> Actor("DigitalOut" + to_string(index), address + (index * x) )
>
> Gibt es einen Weg das std::array so zu initialisieren?

Fast! ;-) Es wäre "nur" ein Array und die Lösung ist etwas unleserlich:

#include <tuple>
#include <type_traits>
#include <iostream>
#include <array>

class actor
{
public:
    explicit actor( int i ) : id_( "DigitalOut" + std::to_string( i ) ) {}

    std::string id() const
    {
        return id_;
    }

private:
    const std::string id_;
};

template < typename T >
struct generate_actor;

template < int I >
struct generate_actor< std::integral_constant< int, I > >
{
    static const actor a;
};

template < int I >
const actor generate_actor< std::integral_constant< int, I > >::a = actor( I );

template < typename ...Ts >
struct unroll_actors;

template < typename ...Ts >
struct unroll_actors< std::tuple< Ts... > >
{
    static const actor actors[ sizeof ...(Ts) ];
};

template < typename ...Ts >
const actor unroll_actors< std::tuple< Ts... > >::actors[ sizeof ...(Ts) ] = { generate_actor< Ts >::a... };

template < typename A, typename B >
struct add;

template < typename ...As, typename ...Bs >
struct add< std::tuple< As... >, std::tuple< Bs... > >
{
    using type = std::tuple< As..., Bs... >;
};

template < int I >
struct generate_actor_args
{
    using type = typename add<
        typename generate_actor_args< I - 1 >::type,
        std::tuple< std::integral_constant< int, I > >
    >::type;
};

template <>
struct generate_actor_args< 1 >
{
    using type = std::tuple< std::integral_constant< int, 1 > >;
};

int main()
{
    const actor (&theater)[ 16 ] = unroll_actors< generate_actor_args< 16 >::type >::actors;

    for ( const auto a : unroll_actors< generate_actor_args< 16 >::type >::actors )
        std::cout << a.id() << std::endl;
}

[Wilhelm M. (wimalopaan)]

So villt:

struct Digital {
    static constexpr const char name[] = "D";
};
struct Analog {
    static constexpr const char name[] = "A";
};

template<typename Type>
class Actor
{
public:
    Actor(const std::string& baseName = Type::name) : name(baseName + std::to_string(numberOfActors)), 
        number(numberOfActors++) {}
    static size_t numberOfActors;
    std::string name;
    const size_t number;
};
template<typename Type>
size_t Actor<Type>::numberOfActors = 0;

template<typename Type>
std::ostream& operator<<(std::ostream& o, const Actor<Type>& a) {
    return o << a.name;
}

int main()
{
    std::array<Actor<Digital>, 3> actors1;
    std::array<Actor<Analog>, 3> actors2;
    
    for(const auto& a: actors1) {
        std::cout << a << std::endl;
    }
    for(const auto& a: actors2) {
        std::cout << a << std::endl;
    }
}

[Oliver S. (oliverso)]

Dr. Sommer schrieb:
> Das ist aber undefiniertes Verhalten , pures Glück dass es funktioniert.
> Wenn man eine Variable (hier Index) innerhalb eines Ausdrucks mehrfach
> verändert passiert etwas Compiler spezifisches...

Hm. Ich erkenne deine Kompetenz normalerweise neidlos an, aber...

... hätte da gerne etwas mehr Info.

Der Standard (C++11, Draft N3376) schreibt:

Within the initializer-list of a braced-init-list, the initializer-clauses, 
including any that result from pack expansions (14.5.3), are evaluated in the order in which they appear. That is, every value computation and
side effect associated with a given initializer-clause
is sequenced before every value computation and side effect associated with any initializer-clause that follows it in the comma-separated list of the
initializer-list.

Oliver

[Wilhelm M. (wimalopaan)]

Nochwas:

template<typename Type>
class Actor2
{
public:
    Actor2(int id) : name(std::string{Type::name} + std::to_string(id)), 
        mId(id) {}
    std::string name;
    const size_t mId;
};

template<typename Type>
std::ostream& operator<<(std::ostream& o, const Actor2<Type>& a) {
    return o << a.name;
}

Actor2<Digital> operator"" _da(unsigned long long v) {
    return Actor2<Digital>(v);
}

Actor2<Analog> operator"" _aa(unsigned long long v) {
    return Actor2<Analog>(v);
}

int main()
{
    std::array<Actor2<Digital>, 3> actors3 = {{1_da, 3_da, 2_da}};
    std::array<Actor2<Analog>, 3> actors4 = {{1_aa, 3_aa, 2_aa}};
}

[Mikro 7. (mikro77)]

Operator S. schrieb:
> Kann man die Position eines Objektes, welches in einem std::array liegt
> seinem eigenen Konstruktor übergeben?

Ich hatte mir mal ein make_array geschrieben, um std::array für 
bestimmte Fälle "dynamisch" initialisierbar zu machen (nicht exception 
safe). Dann könnte man in deinem Fall bspw. über einen std::vector gehen 
und folgerndermaßen verfahren:

#include <array>
#include <iostream>
#include <sstream>
#include <string>
#include <vector>

template <size_t N,typename Iterator>
static std::array<typename std::iterator_traits<Iterator>::value_type,N> make_array(Iterator first,Iterator last)
{
  using T = typename std::iterator_traits<Iterator>::value_type ;
  char buffer[sizeof(std::array<T,N>)] ;
  auto *p = reinterpret_cast<std::array<T,N>*>(&buffer) ;
  for (size_t i=0 ; i<N ; ++i) {
    if (first == last)  
      throw std::runtime_error("make_array:underflow") ;
    new (&(*p)[i]) T(*first) ;
    ++first ;
  }
  if (first != last) 
    throw std::runtime_error("make_array:overflow") ;
  auto array = (*p) ;
  for (size_t i=0 ; i<N ; ++i) {
    (*p)[i].~T() ;
  }
  return array ;
}

struct Actor
{
  std::string s ; int i ;
  Actor(std::string const &s, int i) : s(s),i(i) {}
} ;

struct Device
{
  static Device make()
  {
    std::vector<Actor> v ;
    for (int i=1 ; i<=16 ; ++i)
      v.push_back(Actor("DigitalOut"+std::to_string(i),i)) ;
    return Device(v) ;
  }
  
  Device(std::vector<Actor> const &v) : a(make_array<16>(v.begin(),v.end())) {}
  
  std::string to_str() const
  {
    std::ostringstream os ;
    for (auto &actor : a)
      os << actor.i << ':' << actor.s << '\n' ;
    return os.str() ;
  }
      
private:
  std::array<Actor,16> a ;
} ;

int main()
{
  auto d = Device::make() ;
  std::cout << d.to_str() ;
  return 0 ;
}

[Wilhelm M. (wimalopaan)]

Also ich finds so ganz hübsch:

#include <array>
#include <string>
#include <iostream>

struct Digital {
    static constexpr const char name[] = "Digital";
    static constexpr const uint16_t baseAddress = 0x100;
};
struct Analog {
    static constexpr const char name[] = "Aanalog";
    static constexpr const uint16_t baseAddress = 0x200;
};

template<typename Type> class Actor;
template<typename Type> std::ostream& operator<<(std::ostream& o, const Actor<Type>& a);

template<typename Type>
class Actor
{
    friend std::ostream& operator<< <>(std::ostream& o, const Actor<Type>& a);
public:
    Actor(int id) : name(std::string{Type::name} + std::to_string(id)), mId(id), address(Type::baseAddress + mId) {}
private:
    std::string name;
    const size_t mId;
    const uint16_t address;
};

template<typename Type>
std::ostream& operator<<(std::ostream& o, const Actor<Type>& a) {
    return o << a.name << " : " << a.address;
}

Actor<Digital> operator"" _da(unsigned long long v) {
    return Actor<Digital>(v);
}

Actor<Analog> operator"" _aa(unsigned long long v) {
    return Actor<Analog>(v);
}

int main()
{
    std::array<Actor<Digital>, 3> actors1 = {{1_da, 3_da, 2_da}};
    std::array<Actor<Analog>, 3>  actors2 = {{1_aa, 3_aa, 2_aa}};
    
    for(const auto& a: actors1) {
        std::cout << a << std::endl;
    }
    for(const auto& a: actors2) {
        std::cout << a << std::endl;
    }
}

vielleicht triffts ja den Geschmack...

[Operator S. (smkr)]

Danke für all die Lösungen. Ich hatte gehofft irgendwie std::fill oder 
std::generate einsetzen zu können, um näher am standard zu bleiben und 
weniger eigenen Code zu produzieren, aber das scheint in diesem Fall 
nicht möglich zu sein.
Auch sonst im Netz scheints immer auf template magic hinauszulaufen :)

[Wilhelm M. (wimalopaan)]

Sag das doch gleich:

    int startId = 0;
    std::generate(std::begin(actors1), std::end(actors1), [&](){return Actor<Digital>(startId++);});

[Wilhelm M. (wimalopaan)]

Oder:

    std::vector<Actor<Digital>> v;
    int startId = 0;
    std::generate_n(std::back_inserter(v), 10, [&](){return Actor<Digital>(startId++);});

Allerdings sprachst Du oben von Initialisierung.

Was wir hier geschieht ist ja eine Kopier/Verschiebungszuweisung ...