große mengen an variablen in 2-dim array



  • Hallo ich habe einen Algorithmus, der mehrere zweidimensionale arrays in zweidimensionalen vectoren ablegen soll.
    falls man sich fragt, warum:
    jeder zweidimensionale array wird "hintereinander" in einem vector abgelegt, so dass ich mehrere "matrizen" speichern kann.

    das sieht folgendermaßen aus:

    int i,j,count=0;
    vector<vector<int> > v ; 
    do
    {
    B3(T,m,Part2); // egal, was die macht, daran liegt nicht der fehler
    
    do{
    v.push_back(vector<int>());
    B(T,m,Part2); // egal, was die macht, daran liegt nicht der fehler
    for (i=0; i<m; i++)
        for (j=0; j<m; j++)
            T2[i][j]=T[i][j];
    
    for (i=0; i<m; i++)
        for (j=0; j<m; j++)
            T3[i][j]=T2[i][j];    
    linord(T2,m); // egal, was die macht, daran liegt nicht der fehler
    
    for (i=0; i<m; i++)
        for (j=0; j<m; j++)
            v[count].push_back(T2[i][j]);
    c=0;
    for(i=0;i<m;i++)
        if(T3[i][i]==1)
            c++;
    
    if(c>1)
        {
        linord2(T3,m); // egal, was die macht, daran liegt nicht der fehler
        count++;
        v.push_back(vector<int>());
        for (i=0; i<m; i++)
            for (j=0; j<m; j++)
                v[count].push_back(T3[i][j]);
        }
    
    abb=Btest(T,m,abb,Part2);
    count++;
    
    }while(abb==0);
    

    T, T2 und T3 sind zweidimensionale Arrays, die ich in v[count] ablege und zwar so, dass ich die ganzen zeilen hintereinander anfüge, bei einer entsprechenden ausgabe ergeben sich wieder matritzen, so der plan :). jedoch können auch mehrere matrizen in einem vector abgelegt werden müssen.
    bis zu einer arraylänge 7 funktioniert das auch wunderbar, jedoch kommt nach dimension 8 erst gar nichts (was aufgrund der datenmenge nicht verwundert) aber dann der (mir allzugut) bekannte laufzeit fehler "was forced to terminate it in an unusual way).

    also können in jedem v[i] tausende elemente liegen, und auch v kann eine länge von 10.000 oder mehr haben.

    wie gesagt bis m=7 funktioniert alles wunderbar, danach streikt das programm.
    woran liegt das und wie kann ich es vermeiden, vielen dank für die hilfe im voraus



  • ich würds ja fast ma angucken, aber:
    einrücken wäre toll gewesen...
    und so was:

    for(i=0;i<m;i++)
        if(T3[i][i]==1)
            c++;
    

    ist zwar von der form her ok, aber ich würds niemals so machen, weil ichs unübersichtlich find...

    funktionsnamen, wie B oder B3 find ich auch ne so toll ^^

    c=0;
    

    wo und als was is c deklariert?

    übrigens solltest du dir mal iteratoren angucken - und wenn die arrays wirklich alle immer so groß werden, solltest du ma drüber nachdenken für i, j und count nen unsigned datentyp zu nehmen - unsigned long long würd ich dir ja einfach ma so vorschlagen - da sollte nix mehr schief gehen ^^

    v.push_back(vector<int>());
        for (i=0; i<m; i++)
            for (j=0; j<m; j++)
                v[count].push_back(T3[i][j]);
    

    würd ich anders machen: erst den neuen vector erstellen und befüllen und den dann erst hinten an v anfügen...

    bb



  • vielen dank für die antwort...

    auch mit unsigned long long klappt es genausowenig und wie kann ich in diesem fall erst den vector erst befüllen und dann anfügen?



  • for (size_t i (0); i != m; ++i)
       { 
          std::vector <int> topushback;
          for (size_t j (0); j != m; ++j) //ist hier eigtl bei beiden schleifen das m gewollt? also ist das 2d-array immer quadratisch?
             {
                topushback.push_back(T3[i][j]);
             }
          v.push_back (topushback);
       }
    

    bist du das ganze denn auch ma mit nem debugger durchgegangen?
    da muss man doch merken, wo der fehler liegt ><

    bb

    PS:

    for (i=0; i<m; i++)
        for (j=0; j<m; j++)
            T2[i][j]=T[i][j];
    
    for (i=0; i<m; i++)
        for (j=0; j<m; j++)
            T3[i][j]=T2[i][j];
    

    was spricht hier gegen:

    T2 = T;
    //bzw.
    T3 = T2;
    


  • sry für doppelpost, aber ich hab mir das ganze jz doch ma genauer angeguckt ^^

    size_t count (0);
    std::vector <vector <int> > myvector; 
    
    do //die schleife geht hier nicht zu...
    	{
    		B3 (T, m, Part2); //TODO: ordentlichen Funktionsnamen ausdenken... 
    
    		for (; Btest (T, m, abb, Part2); ++count) //war deine die schleife mit while (abb == 0) oder so
    			{ 
    				myvector.push_back (vector <int>); //warum nen leeren vector hinten ran?
    				B (T, m, Part2); //TODO: ordentlichen Funktionsnamen ausdenken...
    				T2 = T;
    				T3 = T;
    
    				linord (T2, m); //TODO: aussagekräftigeren Funktionsnamen ausdenken...
    
    				{
    				const std::vector <vector <int> >::const_iterator end (T2.end ());
    				for (std::vector <vector <int> >::const_iterator iter (T2.begin ()); iter != end; ++iter)
    					{
    						const std::vector <vector <int> >::const_iterator end_2 (iter->end ());
    						for (std::vector <vector <int> >::const_iterator iter_2 (iter->begin ()); iter_2 != end_2; ++iter_2)
    							{
    								myvector[count].push_back (*iter_2);
    								/*wenn es eh immer der gleiche wert ist, ist es hier vll auch sinnvoller,
    								das ganze erst in nen eigenen vector zu hauen und dann erst hinten ranzupushen.
    								Wenn nicht so, dann wenigstens nen iterator nehmen...*/
    							}
    					}
    				}
    
    				unsigned long long c (0); /*sieht so aus, als ob hier auch nen bool reichen würde - oder gar keine extra variable...
    Sondern statt dem ++c einfach nur der inhalt des if(c)-Blocks rein müsste*/
    				{
    				const std::vector <vector <int> >::const_iterator end (T3.end ());
    				for (std::vector <vector <int> >::const_iterator iter (T3.begin ()); iter != end; ++iter)
    					{
    						const std::vector <vector <int> >::const_iterator end_2 (iter->end ());
    						for (std::vector <vector <int> >::const_iterator iter_2 (iter->begin ()); iter_2 != end_2; ++iter_2)
    							{
    								if (*iter_2 == 1)
    									{
    										++c;
    									}
    							}
    					}
    				}
    
    				if (c) 
    					{ 
    						linord2 (T3, m); //TODO: fkt-name...
    						++count;
    						std::vector <int> topushback; //ist es gewollt, alles in ein und die gleiche zeile zu schreiben?
    						for (size_t i(0); i != m; ++i) //wie das mit iteratoren geht, steht ja weiter oben schon mal
    							{
    								for (size_t j(0); j != m; ++j) 
    									{
    										topushback.push_back (T3[i][j]);
    									}
    							}
    						myvector[count].push_back (topushback);
    					} 
    			}
    	//} fehlt noch...
    

    Es wäre halt auch mal ganz hilfreich zu wissen, was das ganze überhaupt machen soll...

    kein plan, wie viele fehler ich eingebaut hab, die davor noch nich da waren ^^

    bb


Log in to reply