Question

EDIT: Question closed.

Suggested pow of elements

int mypow(int n) { return n * n; }

transform(datos->origen->begin(),datos->origen->end(),datos->cuads->begin(),mypow);

I am trying to get the sum , the min and pow over an int vector concurrently.
I am using ubuntu 11.10 , codelite and g++ with phtreads.

I fill the vector, and spawn a thread per task. But I got wrong result.

I think the code it’s ok, but really not and I don’t why.

Filling the int vector with 10 ints, I got the following execution:

Sum: 110
Min: 2
original container length:10
2
4
6
... to 20

pow container lenght:20
0
0
0
... 10 zeros

4  ----> true result after pow elements
16
36
64
... rest of elements

Main thread ended

Thanks in advance

code:

#include <iostream>
#include <vector>

#include <pthread.h>

using std::cout;
using std::cin;     // C++ uses
using std::endl;
using std::vector;


// struct to store results
typedef struct
{
int suma;
int min;
vector<int>* origen;
vector<int>* cuads;
}tdata;


// mutex
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;


// Adition funct
void *suma(void* ptr)
{

// lock mutex
pthread_mutex_lock( &mutex1 );

tdata* datos = reinterpret_cast<tdata*>(ptr);

// iterator
vector<int>::const_iterator it1 = datos->origen->begin();

while( it1 != datos->origen->end() )
{
    datos->suma += *it1;    
    it1++;
}

pthread_mutex_unlock( &mutex1 );

 return 0;
}

// minimun function
void* min(void *ptr)
{ 

pthread_mutex_lock( &mutex1 );

tdata* datos = reinterpret_cast<tdata*>(ptr);

datos->min = datos->origen->at(0); // inicializo el menor

vector<int>::const_iterator it2 = datos->origen->begin();

while( it2 != datos->origen->end())
{   
    if ( (*it2) < datos->min )
        datos->min = (*it2);

        it2++;  
}

pthread_mutex_unlock( &mutex1 );
    return 0;
 }

// pow function. Dinamically alloc vector and fill it
void* cuadrados( void* ptr)
 {

pthread_mutex_lock( &mutex1 );

tdata* datos = reinterpret_cast<tdata*>(ptr);

// Error int tan = static_cast<int>(datos->origen->size());

datos->cuads = new vector<int>();  // Error new vector<int>(tan);               

vector<int>::const_iterator it3 = datos->origen->begin();

while( it3 != datos->origen->end() )
{       
    int n = (*it3) * (*it3);
    datos->cuads->push_back(n);

    it3++;  
}   
pthread_mutex_unlock( &mutex1 );
  return 0;
 }



int main(int argc, char **argv)
{

#define MAXHILOS 3      // nº de hilos
#define MAXNUMS 10      // cantidad de numeros

vector<int> enteros;    // vector de enteros            

pthread_t hilos[MAXHILOS];  // vector de hilos


    // fill origin vector
    for ( int i = 0; i < MAXNUMS; i++)
            enteros.push_back((i+1)*2);


    // init target structure
    tdata t = {0};

    // point to origin vector
    t.origen = &enteros;

        // thread creation                                  
        pthread_create(&hilos[0],NULL,suma,&t);         
        pthread_create(&hilos[1],NULL,min,&t);
        pthread_create(&hilos[2],NULL,cuadrados,&t);

        // wait until all threads ends
        pthread_join(hilos[0], NULL);
        pthread_join(hilos[1], NULL);
        pthread_join(hilos[2], NULL);


        // show results         
        cout << "Sum: " << t.suma << endl
             << "Min: " << t.min << endl;

        cout << "original vector length:" << enteros.size() << endl;

        vector<int>::const_iterator ent = enteros.begin();

        while( ent != enteros.end() )
        {   
            cout << (*ent) << endl;                             
            ent++;  
        }

        cout << "pow vector length:" << t.cuads->size() << endl;            


        vector<int>::const_iterator cuadr =t.cuads->begin();

        while( cuadr != t.cuads->end() )
        {   
            cout << (*cuadr) << endl;                               
            cuadr++;    
        }


        //delete[] t.cuads;         
        cout << "Main thread ended" << endl;

cin.get();
return 0;
} 

EDIT: Yes, the trouble was creating the vector with fixed size.
Thanks to all. 

Answer 1

I believe the problem is the ten zeros at the beginning of the tdata.cuads
vector. This is caused by:

// This allocates a new vector with 'tan' number of ints
// and initialises them to zero.
datos->cuads = new vector<int>(tan);                

// This loops appends new elements to the 'cuads' vector,
// after the ten zeros.
while( it3 != datos->origen->end() )
{       
    int n = (*it3) * (*it3);
    datos->cuads->push_back(n);

    it3++;  
}   

To correct this either declare create the cuads without an initial size:

datos->cuads = new vector<int>();                

while( it3 != datos->origen->end() )
{       
    int n = (*it3) * (*it3);
    datos->cuads->push_back(n);

    it3++;  
}   

or use the operator[] to populate cuads:

datos->cuads = new vector<int>(tan);                

size_t i = 0;
while( it3 != datos->origen->end() )
{       
    int n = (*it3) * (*it3);
    *(datos->cuads)[i++] = n;
    it3++;  
}   

Few other minor points:

• typedef is not required when defining a struct in C++, just struct tdata { ... };.
• you could use std::accumulate() to calculate the sum of a container and std::min_element() to find the min value of container.

For example:

dataos->suma = std::accumulate(dataos->origen->begin(), dataos->origen->end(), 0);
dataos->min  = *std::min_element(dataos->origen->begin(), dataos->origen->end());