ich hab ne frage, ich soll ein C-Stil fomuliertes Programm in den C++ Still umschreiben. Kann mir hierbei jemand helfen ?

hier mal der code :

#include <stdlib.h>
#include <stdio.h>
int main(void)
{
int i,*ip;
ip=(int *) malloc(10*sizeof(int));

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

wäre nett wenn mir da jemand schnell nachhelfen könnte !!

Gruß Neodeo

Damit kommst du zu:

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

(PS: Der MS-Compiler könnte damit Probleme haben, weil er den Scope für die beiden 'int i' falsch setzt)

#include <cstdlib>
#include <cstdio>

int main()
{
    int* ip = static_cast<int*> (std::malloc (10 * sizeof(int)));

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

#include <iostream>

int main ()
{
    int* ip = new int[10];
    for (int i = 0; i < 10; ++i)
        ip[i] = i + 1;
    for (int i = 0; i < 10; ++i)
        std::cout << ip[i] << ' ';
    std::cout << std::endl;
    delete[] ip;
}

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

class Counter
{
public:
     Counter (int v) : _value (v) {}
     int operator() ()
     {
         return ++_value;
     }
private:
     int _value;
};

int main ()
{
    std::vector<int> v (10);

    std::generate (v.begin (), v.end (), Counter (0));

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

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

und danke für die tipps.. werd sie mir merken

...

...
    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.

Gruß,

Simon2.

könntet ihr mir vllt auch bei dem folgenden code helfen ? also nur falls es euch nicht zuviel ist.. ist halt doch nicht gerade mein ding das umschreiben ^^

#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;
wurzel = (knoten *) malloc(sizeof(knoten));
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);
}
}

naja falls ihr lust habt könnt ihr mir ja gern nochmal helfen. will euch aber nicht überfordern, ich probiere es solang mal weiter alleine...

und danke nochmal für das oben ^^

gruß neodeo

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

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

wurzel = new knoten;

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

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

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

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

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

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

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

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

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

aber danke

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

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

Ä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

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