3. Frage zu C code in C++ umschreiben

Frage zu C code in C++ umschreiben

  • L

    Ich wollte schon auf

    std::cout << "12345678910" << std::endl;

    hinaus 😉

    Also:

    /* ... */
int main ()
{
	std::generate_n (std::ostream_iterator< int > (std::cout, " "), 10, Counter (0));
    std::cout << std::endl;
}
    0
  • N

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

    ich kopier mal den ganzen code, und makier die stelle die ich meine... ich versteh das nämlich nicht ganz...

    #include <stdlib.h> 
#include <stdio.h> 

struct knoten{ 
int nummer; 
knoten *links; 
knoten *rechts; 
}; 

void drucken(knoten * start); 
knoten * wachsen(int); 
int nummer=0; 

int main(void) 
{ 
knoten * kp = wachsen(2); 
drucken(kp); 
return 0; 
} 

knoten * wachsen(int tiefe) 
{ 
knoten*wurzel; 

// DEN TEIL HIER .. 

[u][b]wurzel = (knoten *) malloc(sizeof(knoten)); [/b][/u]

// BIS HIER HIN

if(tiefe > 0 ) { 
wurzel -> links = wachsen(tiefe-1); 
wurzel -> rechts = wachsen(tiefe-1); 
wurze->nummer=++nummer; 
} 
else{ 
wurzel->links = 0; 
wurzel->rechts = 0; 
wurzel -> nummer=++nummer; 
} 
return wurzel; 
} 

void drucken(knoten *start) 
{ 
printf("Nr.: %d ", start->nummer); 

if(start->links){ 
drucken(start->links); 
} 
if(start->rechts){ 
drucken(start->rechts); 
} 
}
    0
  • C

    Wie im oberen Beispiel: Nimm new:

    wurzel = new knoten;
    0
  • ?

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

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

    0
  • W

    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

    0
  • C

    Transformer schrieb:

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

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

    0
  • T

    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);
}

    😉

    0
  • W

    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

    0
  • N

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

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

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

    0
  • W

    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

    0
  • N

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

    aber danke 😃

    0
  • F

    Werner Salomon schrieb:

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

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

    0
  • N
     

    //#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

    0
  • B
     

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

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

    0
Anmelden zum Antworten