Frage zu C code in C++ umschreiben

1. Anstelle von malloc/free solltest du new/delete verwenden.

und was macht man dann aus realloc?
new, kopieren und deleten?

Werner Salomon

Neodeo schrieb:

hey könnt ihr mir kurz nen tipp geben wie ich den teil hier umschreiben kann?

In C++ etwa so:

#include <iostream>

struct knoten
{
    knoten( int tiefe = 0 ) 
        : nummer( ++nummer0 ), links(0), rechts(0) 
    {
        if( tiefe > 0 )
        {
            --tiefe;
            links = new knoten( tiefe );
            rechts = new knoten( tiefe );
        }
    }
    ~knoten()
    {
        if( links ) delete links;
        if( rechts ) delete rechts;
    }

    friend std::ostream& operator<<( std::ostream& out, const knoten& kn )
    {
        out << "Nr.: " << kn.nummer << " ";
        if( kn.links ) out << *kn.links;
        if( kn.rechts ) out << *kn.rechts;
        return out;
    }

    const int nummer; // 'const' verhindert das Kopieren!
private:
    static int nummer0;
    knoten *links;
    knoten *rechts;
};
int knoten::nummer0 = 0;

int main()
{
    using namespace std;
    knoten kp(2);
    cout << kp << endl;
    return 0;
}

Gruß
Werner

CStoll

Transformer schrieb:

und was macht man dann aus realloc?
new, kopieren und deleten?

Genau richtig erkannt - ein renew gibt es in C++ nicht.

ten

Simon2 schrieb:

.filmor schrieb:

...

...
    std::vector<int> v (10);
    
    std::generate (v.begin (), v.end (), Counter (2));

    std::copy (v.begin (), v.end (), std::ostream_iterator (std::cout, " "));

    std::cout << std::endl;
}

Ahhhh, schöööööön.

alles quatsch. so muss das aussehen:

template <typename T>
void count (T n)
{
    T i,*ip;
    ip=(int *) malloc(10*sizeof(int));

    for(i=0;i<n;i++)
        ip[i]=i+1;
    for(i=0;i<n;i++)
        printf("%d ", ip[i]);
    printf("\n");
    free(ip);
}

int main(void)
{
    count<int>(10);
}

Werner Salomon

LordJaxom schrieb:

Ich wollte schon auf
std::cout << "12345678910" << std::endl;
hinaus

.. ist auch schön. Noch die Zwischenräume dazu und es wär' perfekt

Meine beiden Favoriten wären:

#include <iostream>
#include <vector>
#include <iterator>     // ostream_iterator
#include <numeric>      // partial_sum

int main()
{
    using namespace std;
    vector< int > ip(10,1);
    partial_sum( ip.begin(), ip.end(), ostream_iterator< int >( cout, " " ) );
    cout << endl;
    return 0;
}

und - falls der Gebrauch von boost ok ist:

#include <iostream>
#include <iterator>     // ostream_iterator
#include <algorithm>    // copy
#include <boost/iterator/counting_iterator.hpp>

int main()
{
    using namespace std;
    copy( boost::counting_iterator< int >(1), boost::counting_iterator< int >(10+1),
        ostream_iterator< int >( cout, " " ) );
    cout << endl;
    return 0;
}

Gruß
Werner

Neodeo

boah man leute ihr seid die besten !!! danke.. darauf wär ich nie gekommen..

thx nochmal... und super hilfe !!!!

danköööööööööööööööö baba

Werner Salomon

Neodeo schrieb:

boah man leute ihr seid die besten !!!

Na, bei so viel Begeisterung setze ich noch einen drauf. Nehme den Code aus meinem knoten-Posting, füge oben folgendes hinzu:

#include <algorithm>    // fill_n
#include <iterator>     // ostreambuf_iterator

const int IO_TABSIZE = std::ios_base::xalloc();

template< typename E, typename Traits >
std::basic_ios< E, Traits >& tab( std::basic_ios< E, Traits >& io )
{
    std::fill_n( std::ostreambuf_iterator< E >( io.rdbuf() ), io.iword( IO_TABSIZE ), io.fill() );
    return io;
}

template< int TabDelta >
struct indent
{
    explicit indent( std::ios_base& io ) 
        : m_io( io ) 
    {
        m_io.iword( IO_TABSIZE ) += TabDelta;
    }
    ~indent()
    {
        m_io.iword( IO_TABSIZE ) -= TabDelta;
    }
private:
    std::ios_base& m_io;
    indent( const indent& );
    indent& operator=( const indent& );
};

und ändere die Ausgabe von knoten nach:

struct knoten
{
    // (s.o.)
    friend std::ostream& operator<<( std::ostream& out, const knoten& kn )
    {
        out << tab << "Nr.: " << kn.nummer << std::endl;
        indent< 4 > ind( out );
        if( kn.links ) out << *kn.links;
        if( kn.rechts ) out << *kn.rechts;
        return out;
    }

dann erhälst Du folgende Ausgabe:

Nr.: 1
    Nr.: 2
        Nr.: 3
        Nr.: 4
    Nr.: 5
        Nr.: 6
        Nr.: 7

.. auch schön - oder

Gruß
Werner

Neodeo

hehe ja ^^ nur dann würde ich den code gar nicht mehr verstehen ^^

aber danke

finix

Werner Salomon schrieb:

~knoten()
    {
        if( links ) delete links;
        if( rechts ) delete rechts;
    }

... präsentierte ihnen das Redundanzministerium für Redundanz

Neodeo

//#include <stdlib.h> 
//#include <stdio.h> 
include <iostream> 
using std::cout; 

int main(void) 
{ 
//int i,*ip; 
//ip=(int *) malloc(10*sizeof(int)); 
int* ip=new int[10]; 

for(int i=0;i<10;i++) 
  ip[i]=i+1; 
for(int i=0;i<10;i++) 
  //printf("%d ", ip[i]); 
  cout<<ip[i]<<" "; 
//printf("\n"); 
cout<<endl; 
//free(ip); 
delete[]ip; 
}

Ähm sorry wenn ich nochmal störe... aber kann mir vllt noch jemand sagen wie ich das ding umschreiben kann das man einen String der Länge 7 allokieren kann ??

wäre nett müsste das gleich abgeben und hab das in der aufgabe überlesen..

danke im vorraus

Braunstein

char* str7 = new char[8]; // 7 Zeichen + Nullbyte

Vielleicht solltes du mal was über dynamische Speicherverwaltung lesen.
http://tutorial.schornboeck.net/dyn_speicher.htm