MFG ReduX

struct data {
int id;
};
void thread(void* arg)
{
int i = static_cast<data*>(arg)->id;
printf("%d",i);
}
int main(void) {
while(1) {
if(event) {
data forthread;
forthread.id = 4;
pthread_t t2;
pthread_create(&t2,0,(void*)thread,&forthread);
}
}
}

Jedesmal wenn er einen neuen struct anlegt ist es doch automatisch eine andere Adresse im Speicher. Außerdem wenn es nicht thread save wäre dann würde es im Prinzip ja nur den Inhalt ändern?!? Aber das Programm stürtzt ja ab.

MFG ReduX

MFG ReduX

struct data {
  int id;
  char* buffer;
};
void thread(void* arg)
{
int i = static_cast<data*>(arg)->id;
int size = strlen(static_cast<data*>(arg)->buffer);
char* buf = new char[size+1];
strcpy(buf,static_cast<data*>(arg)->buffer);
//blablabla
delete [] buf;
//lösche struct:
delete [] &arg; // Ist das so richtig? 
}
int main(void)
{
//blabla
data* ver = new data;
ver.id = i;
// starte ptherad und übergebe adresse
}

MFG ReduX

struct thread_data_t
{
    unsigned int id;
    char* data;

    thread_data_t(const char* string = NULL, const unsigned int id = 0)
        : data(new char[std::strlen(string)]()), id(id)
    {
        std::strcpy(data, string);
    }
    ~thread_data_t()
    {
        delete [] data;
    }
};

void thread(void* ptr_arg)
{
    thread_data_t* ptr_data(static_cast<thread_data_t*>(ptr_arg));

    // copy data
    const unsigned int id(ptr_data->id);
    char* data(new char[std::strlen(ptr_data->data) + 1]());
    std::strcpy(data, ptr_data->data);

    // TODO: Do something!

    delete [] data;
}

int main()
{
    thread_data_t* ptr_data(new thread_data_t("Test", 10));
    thread(ptr_data);
    delete ptr_data;
}

was du da machen wolltest geht nicht, da du nicht einen void-Zeiger löschen kannst, weil dieser keine Größe hat!

...optimalsten...

Oh Oh Oh ... wenn ich da nicht mal wieder 4 Seiten Germanistik-Diskussion heranrauschen höre !!!

Gruß,

Simon2.

Oh Oh Oh ... wenn ich da nicht mal wieder 4 Seiten Germanistik-Diskussion heranrauschen höre !!!

Gruß,

Simon2.

Och, der Link zu den anderen 8 Seiten von neulich würd doch schon reichen ^^

int main()
{
    thread_data_t* ptr_data(new thread_data_t("Test", 10));
    thread(ptr_data);
    delete ptr_data; // Im thread wurden die Daten wahrscheinlich nochnicht rauskopiert!
}

Kann ich statt im main die daten auch im thread löschen?

MFG ReduX

MFG ReduX

Bzw. was ist daran nicht sauber? gibts dadurch speicherleaks oder so?

Normalerweise sollte derjenige Teil, der den Speicher anfordert, ihn auch wieder freigeben. In diesem Fall ist es meiner Meinung nach aber ok, wenn der Haupthread den Speicher anfordert und der gestartete Thread ihn wieder freigibt. Dürfte auch keine Speicherlecks geben, also von daher alles ok.

Wenn du nur einen Wert übergeben willst und sizeof(Wert)<=sizeof(void*) gilt, dann kannst du deinen Wert auch zu einer Adresse casten, der Thread castet den void-Zeiger wieder auf den Wert um und du brauchst keinen Speicher zu allokieren/freizugeben.

MFG ReduX

struct data
{
    unsigned int id;
    char* info;

    data(const char* string = NULL,const unsigned int id = 0) : info(new char[strlen(string)]),id(id)
    {
        strcpy(info, string);
    }
    ~data()
    {
        delete [] info;
    }
};
void verification(void* arg)
{
data* ptr_data(static_cast<data*>(arg));
unsigned int i(ptr_data->id);
int size = strlen(ptr_data->info);
char* buffer = new char[size+1];
strcpy(buffer,ptr_data->info);
printf("ID: %id, Buffer: %s",i,buffer);
delete [] buffer;
}
int main()
{
while(1) {
if(event) {
data* ver(new data("TestTest",32));
_beginthread(verification,0,&ver);
}
}
}

MFG ReduX

Oder einfach std::string verwenden...

und darf man fragen, wieso du Variablen so data* ver(new data("TestTest",32)); initialisierst, anstatt data* ver = ... ?

Aber einfacher:

#include <string>

void verification(void* arg)
{
    data* ptr_data(static_cast<data*>(arg));
    std::cout << "ID: " << ptr_data->id << ", Buffer: " << ptr_data->info << std::endl;
}

...

#include <cstring> // std::strcpy, std::strlen
#include <iostream> // std::cout, std::endl
#include <string> // std::string

struct data
{
    unsigned int id;
    std::string info;

    data( const std::string str="", const unsigned int id=0 ) : info(str), id(id)
    { }
};

void verification( void* arg )
{
    data* my_data = reinterpret_cast<data*>( arg );
    std::cout << "ID: " << my_data->id << ", Buffer: " << my_data->buffer << std::endl;
    delete my_data;
}

int main()
{
    while(1)
    {
        if (event)
        {
            ::_beginthread( verification, 0, new data("TestTest",32) );
        }
    }
}

buf[1024];
rc = recv();
buf[rc] = '\0';

ist das notwendig?

MFG ReduX