ich möchte aus einer Matrix seine Zeilenvektoren rausholen. Habe folgendes gemacht:

int const M = 7;
int const N = 7;

double d[M][N]={0};

for (i=0; i<M; i++)
{   
    for (j=0; j<N; j++)  
    {          
        zeile1[j] = d[i][j];
        zeile2[j] = d[i][j];
        ...
        zeile7[j] = d[i][j];
    }
}

Es gibt für dieses bsp also 7 Zeilenvektoren, die als "zeile1 bis zeile7" gespeichert sind. Nur ich möchte das ganze automatisieren lassen, damit der Programmcode bei 100x100 Matrix kürzer wird. Z.B:

zeile_i[j] = d[i][j];

Wie könnte man das lösen?

Vielen Dank im Voraus!

Im Zweifelsfall bitte auch folgende Hinweise beachten:
C/C++ Forum :: FAQ - Sonstiges :: Wohin mit meiner Frage?

Dieses Posting wurde automatisch erzeugt.

std::size_t 2dim_to_1dim(std::size_t x, std::size_t y, std::size_t width)
{
    return y * width + x;
}
std::size_t 3dim_to_1dim(std::size_t x, std::size_t y, std::size_t z, std::size_t width, std::size_t height)
{
    return z * height + y * width + x;
}

Das wird notwendig, weil man als guter C++-Programmierer keine C-Style-Arrays/Pointer mehr verwendet.

Ich habe mal gelesen, dass man std::vector<std::vector<int>> nicht verwenden sollte.
Weiß einer wieso oder ist das Quatsch?

Wrappen heißt: einen zweidim auf einen eindim abbilden.

Was ich meine, ist was du fälschlicherweise als wrappen beschreibst.

Nathan schrieb:

Ich habe mal gelesen, dass man std::vector<std::vector<int>> nicht verwenden sollte.
Weiß einer wieso oder ist das Quatsch?

Außer, dass es ein wenig Speicher-verschwenderisch ist, dazu vielleicht teilweise unschön* - spricht nichts dagegen.
(Gerade der letzte Punkt ist aber definitiv ein Grund zum Nachdenken ;))

* Beispiel: Du möchtest drüberiterieren. Oder wie ein C-Array behandeln, bzw. einer Funktion ein C-Array mit selbem Inhalt geben usw.

A(3x2) = (1 2; 3 4; 4 5)

=> zeile1 = 1 2
zeile2 = 3 4
zeile3 = 4 5

Wieso, für mich ist das auch Wrappen. :p

Am Besten alles in einen vector wrappen. Wer Lust hat, ein Zeilen-Iterator wäre ne nette Idee.

Minimaler Ansatz:

template<typename T>
class matrix2d
{
private:
    vector<T> storage;
    size_t width, height;

public:
    matrix2d(size_t width, size_t height)
        : storage(width * height), width(width), height(height)
    { }

    T& operator(size_t x, size_t y)
    {
        assert(x < width && y < height);
        return y * width + x;
    }
};

// Library MySTL
// multiarray.hpp
// More-dimensional arrays/vectors

#ifndef MULTIARRAY_HPP_INCLUDED
#define MULTIARRAY_HPP_INCLUDED

#include <array>
#include <map>
#include <stdexcept>
#include <tuple>
#include <type_traits>
#include <vector>

#include <iostream>

namespace my
{
namespace stl
{
    // Forwards
    template <std::size_t dims>
    class multi_array_index_t;
    template <std::size_t dims>
    class multi_array_getter;

    /// \brief A more-dimensional, dynamic growing vector, based on a spezific STL-Container
    /// \param T: the type of the multi_array
    /// \param dims: the number of dimensions (more than one is recommend!)
    /// \param G: the getter function for the multi_array (says how the values are stored); default: multi_array_getter
    /// \param C: the container storing the values, must have a random_access_iterator (vector or deque); default: vector
    template <typename T, std::size_t dims, template<std::size_t> class G = multi_array_getter, template<typename, typename...> class C = std::vector>
    class multi_array
    {
    public:
        // Typedefs
        /// \brief The type and its references, const_references, allocators and pointers
        using value_type            = typename C<T>::value_type;
        using allocator_type        = typename C<T>::allocator_type;
        using reference             = typename C<T>::reference;
        using const_reference       = typename C<T>::const_reference;
        using pointer               = typename C<T>::pointer;
        using const_pointer         = typename C<T>::const_pointer;

        /// \brief The getter class and the container
        using getter    = G<dims>;
        using container = C<T>;

        /// \brief The iterators
        using iterator               = typename C<T>::iterator;
        using const_iterator         = typename C<T>::const_iterator;
        using reverse_iterator       = typename C<T>::reverse_iterator;
        using const_reverse_iterator = typename C<T>::const_reverse_iterator;

        /// \brief Type representing an index in the multi_array
        using index_t   = multi_array_index_t<dims>;
        /// \brief Type representing a size in the multi_array
        using size_type = multi_array_index_t<dims>;

        // Static Functions
        /// \brief Returns the dimensions of the multi_array
        static constexpr std::size_t dimensions() noexcept {return dims;}

    public:
        // Constructors
        /// \brief Default Constructor
        multi_array() = default;
        /// \brief Constructor
        /// Initalize the multi_array with a size and another container (optional)
        /// \param size: the size (from type size_type)
        /// \param container: the other container (from type container) (optional)
        explicit multi_array(size_type size) : size_(size) {}
        multi_array(size_type size, const container  &container);
        multi_array(size_type size, const container &&container);

        // Iterators
        /// \brief Common iterator access
        /// Is like any other iterator access, see STL-Documentation
        iterator begin() noexcept;
        const_iterator begin() const noexcept;
        iterator end() noexcept;
        const_iterator end() const noexcept;

        reverse_iterator rbegin() noexcept;
        const_reverse_iterator rbegin() const noexcept;
        reverse_iterator rend() noexcept;
        const_reverse_iterator rend() const noexcept;

        const_iterator cbegin() const noexcept;
        const_iterator cend() const noexcept;

        const_reverse_iterator crbegin() const noexcept;
        const_reverse_iterator crend() const noexcept;

        /// \brief Iterator access to certain sequences (rows, columns, etc.)
        /// \param iterator_t: a typename for the return type (a typename)
        /// \param dimension: the dimension you want to access (0 for the first (default: x-dimension), 1 for the second,...) (from type std::size_t)
        /// \param position: the position where the sequence is located, the dimension set with dimension will be ignored (from type index_t)
        /// \param begin: a function returning an iterator from type iterator_t to the first object (function pointer) (default: begin)
        /// \return an iterator to the start of the sequence and one to the end (from type std::pair<iterator_t, iterator_t)
        template <typename iterator_t = decltype(multi_array::begin())>
        std::tuple<iterator_t, iterator_t> range(std::size_t dimension, index_t position);
        template <typename iterator_t = decltype(multi_array::cbegin())>
        std::tuple<iterator_t, iterator_t> range(std::size_t dimension, index_t position,
                                                iterator_t (multi_array::*begin) (void)) const;

        /// \brief Iterator access to certain levels (like range, but more-dimensional)
        /// \param iterator_t: a typename for the return type (a typename)
        /// \param dimensions: how many dimensions you want to access (from type std::size_t)
        /// \param dimension: the dimensions you want to access (from type std::array<std::size_t, dimensions>)
        /// \param position: the position where the level is located (from type

        // Capacity
        /// \brief Get the size of the multi_array
        /// \return The current size of the multi_array (from type size_type)
        constexpr size_type size() noexcept;

        /// \brief Get the maximum size of the multi_array
        /// \return The maximum size of the multi_array (from type std::size_t)
        constexpr std::size_t max_size() noexcept;

        /// \brief Check wether container is empty or not
        /// \return true if the container is empty, false otherwise (from type bool)
        constexpr bool empty() noexcept;

        /// \brief Resize the multi_array, behaves like the resize of the container
        /// \param size: the new size of the multi_array (from type size_type)
        /// \param value: an initialization value for the new values (from type value_type) (default: value_type())
        void resize(size_type size, const value_type &value = value_type());

        // Element access
        /// \brief Get element
        /// \param at: the position of the element (from type index_t)
        /// \return The element at the position at (from type reference/const_reference)
        reference       operator [] (index_t at);
        const_reference operator [] (index_t at) const;

        /// \brief Get element, if it has a wrong index, std::out_of_range is thrown
        /// \param at: the position of the element (from type index_t)
        /// \return The element at the position at (from type reference/const_reference)
        reference       at(index_t at);
        const_reference at(index_t at) const;

        /// \brief Get the data of the container
        /// \return The container (copy) (from type container)
        container data() const noexcept;

        // Modifiers
        /// \brief Assign the multi_array with another multi_array (like operator =)
        /// \param array: the other multi_array (from type multi_array)
        void assign(const multi_array  &array);
        void assign(const multi_array &&array);

        /// \brief Assign the multi_array with another container and a new size
        /// \param size: the new size (from type size_type)
        /// \param container: the container (from type container)
        void assign(size_type size, const container  &container);
        void assign(size_type size, const container &&container);

        /// \brief Assign the multi_array with another container; size remains the same
        /// \param container: the container (from type container)
        void assign(const container  &container);
        void assign(const container &&container);

        /// Size can't be modified directly, so objects can't be inserted.

        /// \brief Swaps the content of this multi_array and another, size is swapped too
        /// \param other: the other multi_array (from type multi_array)
        void swap(multi_array &other);

        /// \brief Clears the multi_array, container has no objects any longer, size is 0 in all dimensions.
        void clear();

    private:
        container container_; ///< The one-dimensional container which stores the data
        size_type size_; ///< The size of the MultiArray
        getter get_; ///< The Getter of the MultiArray
    };

    /// \brief An index-type for the multi_array based on an std::array<std::size_t, dims>
    /// \param dims: the dimension of the index_t (from type std::size_t)
    template <std::size_t dims>
    class multi_array_index_t : public std::array<std::size_t, dims>
    {
    public:
        /// \brief Default Constructor
        multi_array_index_t() = default;

        /// \brief Constructor
        /// Initialize with an initializer-list
        /// \param il: the initializer-list (from type std::initalizer_list<std::size_t>)
        multi_array_index_t(std::initializer_list<std::size_t> il) noexcept;

        /// \brief Get the length of the index_t
        /// \return The length of the index_t (from type std::size_t)
        constexpr std::size_t length() noexcept;
    };

    /// \brief A getter class for a multi_array
    /// This class converts more-dimensional indices to a one-dimensional
    /// \param dims: the dimensions of the getter (from type std::size_t)
    template <std::size_t dims>
    class multi_array_getter
    {
    public:
        /// \brief Operator ()
        /// Converts more-dimensional indices to a one-dimensional
        /// \param position: the position being converted (from type multi_array_index_t<dims>)
        /// \param size: the size of the relating multi_array (from type multi_array_index_t<dims>)
        /// \return the one-dimensional coordinates (from type std::size_t)
        std::size_t operator () (multi_array_index_t<dims> position, multi_array_index_t<dims> size) const noexcept;

        /// \brief Operator ()
        /// Converts one-dimensional indices to more-dimensional
        /// \param index: the one-dimensional index (from type std::size_t)
        /// \param size: the size of the related multi_array (from type multi_array_index_t<dims>)
        /// \return the more-dimensional coordinates (from type multi_array_index_t<dims>)
        multi_array_index_t<dims> operator () (std::size_t index, multi_array_index_t<dims> size) const noexcept;
    };

    #include "impl\multiarray-impl.hpp"

} // namespace stl
} // namespace my

#endif // MULTIARRAY_HPP_INCLUDED

double* zeile = d[i];

schon ziemlich gut beraten. Dann brauchst du auch kein zeile1 etc. Ist leider nicht genau herauszubekommen was du brauchst.

double* d = &d[0][0];

Wenn du wirklich I Variablen namens zeile_1,...,zeile_n erstellen möchtest, müsstest du mit dem Präprozessor arbeiten. Da kenne ich mich aber nicht hinreichend gut aus, aber es müsste imo machbar sein.

zeile_i[j] = Matrix[i][j];
<=>
zeile[i][j] = Matrix[i][j];

Merkste was?

Da bei deinem 2dim Array die Zeilen sowieso hintereinander im Speicher liegt macht das alles keinen Sinn irgendwie.
Willst du an die Spalten ran, bräuchtest du nur transponieren.

Vllt willst du alles ja an eine Funktion übergeben. Das geht auch:

double tolle_funktion (double *zeile, int dim_zeile)
{
  // unglaublicher code
}

tolle_funktion( Matrix + dim_spalte*zeile, dim_zeile);

oder auf Spalten

tolle_funktion ( Matrix_transponiert + dim_zeile*spalte, dim_spalte);

Aber irgendwie ist das alles auch kein C++