Domyślny argument dla referencji tablicy std::array

Question

Cześć w jaki sposób zdefiniować domyślną referencje do tablicy std::array tak żebym nie musiał podawać argumentu color podczas wywoływania funkcji, czy sprawę blokuje tutaj szablon?

 

próbowałem std::array<_Tp, _SIZE_COLOR> & color=(std::array<float,8>{}) , i używam jako:

this->rawModel = loader.loadToVAO<float>(arrayPosition);  ale nie działa.

 

co ciekawe jak zrobię to tak:

std::array<float,8> color={};

std::array<float, 8> arrayPosition=this->createVertexPosition(position);

this->rawModel = loader.loadToVAO<float>(arrayPosition,color);

to jest ok.

template <typename _Tp, std::size_t _SIZE_POSITION, std::size_t _SIZE_COLOR>
    std::shared_ptr<RawModel> loadToVAO(std::array<_Tp, _SIZE_POSITION> & position, std::array<_Tp, _SIZE_COLOR> & color)
    {
        VertexArray *vao = new VertexArray();
        vao->Bind();
        VertexBuffer *vbo = new VertexBuffer(position._M_elems, sizeof(_Tp) * position.size());
        VertexBufferLayout layout;
        layout.Push<_Tp>(2);
        vao->AddBuffer(vbo, layout);

        VertexBuffer *vbo_color=new VertexBuffer(color._M_elems, sizeof(_Tp)*color.size());
        
        VertexBufferLayout layout2;
        layout2.Push<_Tp>(3);
        vao->AddBuffer(vbo_color, layout2);      

        std::shared_ptr<RawModel> rawModel(new RawModel());
        rawModel->addVAO(vao);
        return rawModel;
    }

czy lepszym rozwiązaniem ze względu na to że używam templatu to moze overload?

 

Pozdrawiam

 

Comments

Dobrze Cię zrozumiałem? Domyślną wartość do referencji czyli taką która wystąpi jeśli nie będzie podana żadna???

---

tak

---

No to przeczytaj jeszcze raz pogrubione. Co ma zrobić kompilator jak nic nie podasz? Ma zrobić Ci obiekt r-value? Na co FIZYCZNEGO (w sensie zmiennej) ma wskazać ta referencja?

---

No miałaby być na referencje tablicy pustej std::array<float,8>

jeżeli jest to const reference to powinno zadziałać.

---

problemem raczej (tak mi sie wydaje) jest to ze ten template pozwala na wrzucenie tablicy bez podawania jawnie ilosci elementów

 

bo cos takiego powinno zadziałać:

static int AVAL = 1;

void f( int & x = AVAL ) {
   // stuff
} 

int main() {
     f();       // equivalent to f(AVAL);
}

a krzyczy w moim przypadku że:

note: couldn't deduce template parameter '_SIZE_COLOR'

czyli jakby w template się nie domyślał jaką tablice podaje jako argument domyślny

 

---

No ale u Ciebie nie było stałej :)

Jeśli ze stałą to (poobcinany Twój przykład):

#include <memory>
#include <array>
#include <iostream>

struct RawModel {
};

template <typename _Tp, std::size_t _SIZE_POSITION, std::size_t _SIZE_COLOR = 8>
    std::shared_ptr<RawModel> loadToVAO(std::array<_Tp, _SIZE_POSITION> & position, const std::array<_Tp, _SIZE_COLOR>& color = std::array<float, _SIZE_COLOR>())
    {
        std::shared_ptr<RawModel> rawModel(new RawModel());
        return rawModel;
    }

int main() {
    std::array<float, 10> ar = {{}};
    auto vo = loadToVAO<float>(ar);
}

Dla sprawdzenia całego kontekstu i ew. sensu, za mało kodu...

---

racja sorry, nie spojrzałem, ale niestety dalej nie działa.

---

rozwiązałem to w mało elegancki sposób

 

#pragma once
#include "RawModel.h"
#include <memory>
#include <array>


 static std::array<float,8> COLOR={};
class Loader
{
  public:
    Loader();
     ~Loader();
    std::shared_ptr<RawModel> loadToVAO(const void *position, const void *color);

    template <typename _Tp, std::size_t _SIZE_POSITION, std::size_t _SIZE_COLOR>
    std::shared_ptr<RawModel> loadToVAO(const std::array<_Tp, _SIZE_POSITION> & position,const std::array<_Tp, _SIZE_COLOR> & color=COLOR)
    {
        VertexArray *vao = new VertexArray();
        vao->Bind();
        VertexBuffer *vbo = new VertexBuffer(position._M_elems, sizeof(_Tp) * position.size());
        VertexBufferLayout layout;
        layout.Push<_Tp>(2);
        vao->AddBuffer(vbo, layout);

        VertexBuffer *vbo_color=new VertexBuffer(color._M_elems, sizeof(_Tp)*color.size());
        
        VertexBufferLayout layout2;
        layout2.Push<_Tp>(3);
        vao->AddBuffer(vbo_color, layout2);      

        std::shared_ptr<RawModel> rawModel(new RawModel());
        rawModel->addVAO(vao);
        return rawModel;
    }

   
    template <typename _Tp, std::size_t _SIZE_POSITION>
    std::shared_ptr<RawModel> loadToVAO(const std::array<_Tp, _SIZE_POSITION> & position)
    {
       return this->loadToVAO<float>(position, COLOR);
    }
    

  private:
    VertexArray createVAO(const void *position, const void *color);
     
};

template <typename V, typename... T>
constexpr auto array_of(T &&... t)
    -> std::array<V, sizeof...(T)>
{
    return {{std::forward<T>(t)...}};
}