das array sieht damit so aus: std::vector = 1 0 4 0 0 0 -2 1 2 0 3 2 0 0 0

die ergebnismatrix sieht dann so aus:
1 0 4
-2 1 2
0 3 2

es wurden also zeile 1 und 4 gelöscht.
der vector sieht so aus: std::vector = 1 0 4 -2 1 2 0 3 2

Irgendwie stelle ich mich da dumm an.

Mein code der das schonmal schafft sieht so aus wobei ich glaub das er sehr ineffizient ist. Für Vorschläge bin ich sehr dankbar!!!

int offset = 0;
bool found = 0;
for(int row = 0; row < nbr_Matrix_rows; row++)
{   
    for(int col = 0; col < y_dim; col++)
    {
        offset = col + row * y_dim;
        if (tmp_Matrix[offset] != 0)
        {
            erg_Matrix.push_back(tmp_Matrix[offset]);
            continue;
        }
        for(int r = 0; r < nbr_Matrix_rows; r++)
            if(tmp_Matrix[col + r * y_dim] != 0.0)
                found = 1;
        if(found)
             erg_Matrix.push_back(tmp_Matrix[offset]);
        found = 0;
    }
}

for(int i = 0; i < nbr_Matrix_rows; ++i)
    {
        int idx = i * y_dim;
        bool found = true;

        for(int j = 0; found && j < y_dim; ++j)
            found = !vec[idx+j];

        if(found)
        {
            vector<int>::iterator it = vec.begin() + idx;
            vec.erase(it,it+y_dim); // löscht die zeile
            --rows;                 // anpassen der zeilen anzahl
            --i;                    // anpassen der aktuellen Zeile
        }
    }

Wie du siehst ist er nicht viel anders als dein code

BR
Vinzenz

for ( int i = 0; i < rows; ++i )
	{
		std::vector< int >::iterator it = matrix.begin()+i*dim;
		int num = count_if( it, it+dim, std::bind2nd( std::equal_to< int >(), 0 ) );

		if ( num == 3 )
		{
			matrix.erase( it, it+dim );
			--rows;
			--i;
		}
	}

for ( std::vector< int >::iterator it = matrix.begin(); it != matrix.end(); )
{
    if ( find_if( it, it + dim, std::bind2nd( std::not_equal_to< int >(), 0 ) ) == it + dim )
        it = matrix.erase( it, it + dim );
    else
        it += dim;
}

camper schrieb:

for ( std::vector< int >::iterator it = matrix.begin(); it != matrix.end(); )
{
    if ( find_if( it, it + dim, std::bind2nd( std::not_equal_to< int >(), 0 ) ) == it + dim )
        it = matrix.erase( it, it + dim );
    else
        it += dim;
}

hat allerdings O(n^2) komplexität. effizienter dürfte

std::vector< int >::iterator t = matrix.begin();
for ( std::vector< int >::iterator it = t; it != matrix.end(); it += dim )
{
    if ( find_if( it, it + dim, std::bind2nd( std::not_equal_to< int >(), 0 ) ) != it + dim )
    {
        copy( it, it + dim, t );
        t += dim;
    }
}
matrix.erase( t, matrix.end() );

sein.

habt ihr das auch getestet? wenn ich die ausgangsmatrix nach der schleife ausgebe scheint sich rein gar nichts geändert zu haben.
Ich habe es mit jeder Methode versucht die ihr gepostet habt. AN meiner ausgabe liegt es nicht das habe ich bereits überprüft. Ich lege die Matrix auch nur so an:

std::vector<double> matrix;

und fülle sie dann mit push_back. Mehr auch nicht.

Es kann doch nicht daran liegen dass ich double als type des vectors hernehme...natürlich habe ich die int durch double im code von euch ersetzt.
Er läuft zwar in die Schleifen aber das erase scheint nicht zu klappen...naja ich mach mich mal weiter nach der Fehlersuche.

hier mal mein testcode

std::vector<int> matrix;
    matrix.push_back(0);
    matrix.push_back(4);
    matrix.push_back(2);
    matrix.push_back(0);
    matrix.push_back(3);
    matrix.push_back(2);
    matrix.push_back(0);
    matrix.push_back(2);
    matrix.push_back(1);
    int dim = 3;
    std::vector< int >::iterator t = matrix.begin(); 
    for ( std::vector< int >::iterator it = t; it != matrix.end(); it += dim ) 
    { 
        if ( find_if( it, it + dim, std::bind2nd( std::not_equal_to< int >(), 0 ) ) != it + dim ) 
        { 
            copy( it, it + dim, t ); 
            t += dim; 
        } 
    } 
    matrix.erase( t, matrix.end() );

    std::cout << "Test-------------: " << std::endl;
    std::vector<int>::iterator it2;
    for(it2 = matrix.begin(); it2 != matrix.end(); it2++)
        std::cout << *it2 << std::endl

ich speichere spaltenweise

ausserdem ändert das nichts an der tatsache.

Folgender code ist da ebenfalls für mich nicht ganz verständlich. Anscheinend hab ichs erase nicht kapiert:

std::vector<char> alphaVector;
    for( int i=0; i < 10; i++ ) {
        alphaVector.push_back( i + 65 );
    }
    int size = alphaVector.size();
    std::vector<char>::iterator startIterator;
    std::vector<char>::iterator tempIterator;
    std::vector<char>::iterator ittest;
    for( int i=0; i < size-3; i++ ) {
        startIterator = alphaVector.begin();
        alphaVector.erase( startIterator );
   // Display the vector
        //for( tempIterator = alphaVector.begin(); tempIterator != alphaVector.end(); tempIterator++ ) {
          //  std::cout << *tempIterator;
        //}
        //std::cout << std::endl;
    }

    for (ittest = alphaVector.begin(); ittest != alphaVector.end(); ittest++ ) 
        std::cout <<  *ittest << std::endl;

ich speichere spaltenweise

Tja, in deiner ursprünglichen Frage war es ganz offensichtlich zeilenweise. Da sollte es dich nicht wundern, dass das nicht klappt.

meine ersten versuche den code zu ändern sind ganz schön schwer für nen Anfänger...
das dumme ich ich muss zeilenweise durchlaufen habe aber eine spaltenweise speicherung.

also:
0 0 0
3 2 1
0 0 0

ist so gespeichert: 0 3 0 0 2 0 0 1 0

und soll so ergebnis sein:
3 2 1
und so als ergebnis abgespeichert sein: 3 2 1

ich merke gerade dass das die sache aufwändig macht, da ich es aber leider so brauche wäre es nett wenn wir die sache noch mal aufrollen könnten: Ich glaube zusätzlich dass es nicht in einer Komplexität < O^2 zu lösen ist.
Ein find_if ist jetzt auch nimmer möglich weil ich ja sprünge machen muss.

Danke für erneute Hilfestellungen...

#include <iostream>
#include <ostream>
#include <vector>
#include <algorithm>
#include <iterator>
#include <functional>

struct IsMasked
{
    IsMasked(const std::vector< double >& matrix, const std::vector< bool >& mask) : matrix_( &matrix ), mask_( mask ) {}
    bool operator()(const double& f) const
    {
        return mask_[ ( &f - &*matrix_->begin() ) % mask_.size() ];
    }
    std::vector< bool > mask_;
    const std::vector< double >* matrix_;
};
void erase_null(std::vector< double >& matrix, int x_dim, int& y_dim)
{
    std::vector< bool > mask( y_dim );
    for ( int y = 0; y < y_dim; ++y )
    {
        mask[ y ] = true;
        for ( int x = 0; x < x_dim; ++x )
        {
            if ( matrix[ x * x_dim + y ] != 0 )
            {
                mask[ y ] = false;
                break;
            }
        }
    }
    matrix.erase( std::remove_if( matrix.begin(), matrix.end(), IsMasked( matrix, mask ) ), matrix.end() );
    y_dim = matrix.size() / x_dim;
}

void main()
{
    std::vector<double> matrix;
    matrix.push_back(0);
    matrix.push_back(4);
    matrix.push_back(2);
    matrix.push_back(0);
    matrix.push_back(3);
    matrix.push_back(2);
    matrix.push_back(0);
    matrix.push_back(2);
    matrix.push_back(1);
    int x_dim = 3, y_dim = 3;
    for ( int y = 0; y < y_dim; ++y )
    {
        for ( int x = 0; x < x_dim; ++x )
            std::cout << matrix[ x * y_dim + y ] << '\t';
        std::cout << std::endl;
    }

    std::cout << "*******" << std::endl;

    erase_null( matrix, x_dim, y_dim );

    for ( int y = 0; y < y_dim; ++y )
    {
        for ( int x = 0; x < x_dim; ++x )
            std::cout << matrix[ x * y_dim + y ] << '\t';
        std::cout << std::endl;
    }
}

besonders elegant ist das nicht, aber dafür auch nicht schwer zu verstehen. wollte man hier auch find_if & co einsetzen, müsste man sich einen geeigneten iterator basteln, das ist für diesen einen einsatz allerdings ein wenig overkill.

int t = 0;
for ( int s = 0; s < matrix.size(); ++s )
    if ( !mask[ s % y_dim ] )
        matrix[ t++ ] = matrix[ s ];
matrix.resize( t );

das habe ich nun soweit begriffen. Aber könntest du/ihr mir noch kurz das struct erklären. Ich blick vor allem beim bool operator net ganz durch

struct IsMasked 
 { 
     IsMasked(const std::vector< double >& matrix, const std::vector< bool >& mask) : matrix_( &matrix ), mask_( mask ) {} 
     bool operator()(const double& f) const 
     { 
         return mask_[ ( &f - &*matrix_->begin() ) % mask_.size() ]; 
     } 
     std::vector< bool > mask_; 
     const std::vector< double >* matrix_; 
 };

entspricht dem ausdruck

mask[ s % y_dim ]

in der version mit schleife. die schwierigkeit ist, an den index s heranzukommen. hierbei nutze ich aus, dass vector seine daten kontinuierlich speichert, und nutze pointerarithmetik.
ich hätte auch

mask_[ ( &f - &(*matrix_)[0] ) % mask_.size() ]

schreiben können, aber ich bin kein großer fan von vermeidbaren klammern