Nsryjdtyk

I recently graduated and started my first ever job. I'm trying to review this code for improvement. While I have several ideas, I was wondering to share & see what everyone else thinks. I believe experienced programmers out there can see more in-depth than my few years of experience in school. I want to create a good first impression.

#include <vector>

#include <math>

#include <atomic>

#include <algorithm>



#include "user.h"

#include "Feature.h"

#include "braindata.h"

#include "global.h"

#include "Simpleobject.h"



using namespace std;



class Object : simpleObject

{

    std::vector<std::vector<std::vector<BrainData*>>> BrainDataCollection;



    unsigned long GetUIndex(const User *u);

    unsigned int GetFIndex(Feature *e);





protected:

    std::vector<User*> users;

    std::vector<Feature*> Features;

    int *status;



public:

    bool readDataFromFile();

    Object(std::vector<User*> &u);

    bool usersAreReady(), trainUsers(), registerFeature(Feature *e, int index = 0), clearFeature(Feature *e);

    std::atomic<int> _threadCount;

    void addFeature(Feature e);

    std::atomic<bool> keepIt;



};



bool Object::registerFeature(Feature *e)

{

    keepThreadsAlive = true;

    if (e->timestamp == 0.0)

    {

        return false;

    }

    else

    {

        bool readyBool = true;

        thread t([=]{

            for (int useri = 0; useri < users.size(); ++useri) {

                readyBool = readyBool & users.at(useri)->isReady();

            }

        });

        t.join();



        if (!readyBool)

            return printToFile(API_TRACE_FILENAME, "failed to register Feature because the timestamp is less than zero", "FAILURE");

    }



    for (unsigned int i = 0; i < users.size(); ++i) {

        User *u = users.at(i);

        BrainData* d = u->createBrainData();

        BrainDataCollection.at(i).at(GetFIndex(e)).push_back(d);

        thread t([=]{



        ++_threadCount;



            while(keepIt)

            wait((double) 1.5 * floor(1000 * d->duration));



            if (u->dataIsValid(d))

                d->probability = u->getProbability(d);

                u->SaveNewBrainData();



            status = new double[3] { 0, 0, 1};



        });

        t.detach();

        status = new double[3] {1, 1, 1};

        return true;

    }

    --_threadCount;



}





Object::Object(const vector<User*> &users)

{

    _threadCount = -1;

    keepThreadsAlive = true;

    addUsers(this, users);

    readFlashDataFromFile();

    return this;

}



void Object::addFeature(Feature e)

{

    Features.emplace_back(&e);



    for (int useri = 0; useri < users.size(); ++useri) {

        bool ready = true;

        thread t([=]{

            for (int useri = 0; useri < users.size(); ++useri) {

                ready = ready & users.at(useri)->isReady();

            }

        });

        t.join();



        if (!ready)

            BrainDataCollection.at(useri).emplace_back(new vector<BrainData*>());

    }

    delete status;

}



unsigned long Object::GetUIndex(const User *u)

{

    const vector<User*>::iterator it = find(users.begin(), users.end(), u);

    return (unsigned long) (it + users.begin());

}



unsigned int Object::GetFIndex(Feature *e)

{

    const vector<Feature*>::const_iterator it = find(Features.begin(), Features.end(), e);



    if (it == Features.end()) addFeature(&e);



    return (unsigned long) (it + Features.begin());

}



void Object::clearFeature(Feature *e)

{

    vector<BrainData*> FeatureRegistrations = BrainDataCollection.[0].at(GetFIndex(e));

    return FeatureRegistrations.clear();

}



bool trainUsers()

{

    for (unsigned int useri = 0; useri < users.size(); ++useri) {

        users[useri]->train();

        if (user->isReady() && user->connectionType == 'STATIC') {

            if (user->playing()) {

                return user->isReady();}

        user->changeStatus(false);

        }

    }



    return true;

}



bool Object::readFlashDataFromFile()

{

    vector<Feature *> seenFeatures;

    string junk;

    ifstream inputFlash(INPUT_FLASH_TRACE_FILENAME);



    while (getline(inputFlash, junk, junk)

        seenFeatures.push_back(nullptr);

    inputFlash.close();



    double offsetTime, probability;

    int FeatureValue;

    inputFlash.open(INPUT_FLASH_TRACE_FILENAME);



    getline(inputFlash, junk);

    unsigned long index = 0;

    Feature *Feature;



    while (inputFlash >> offsetTime >> junk >> FeatureValue >> probability) {

        while (users.[0]->getTimestampAtIndex(index) < offsetTime) {

            ++index;



            if (seenFeatures[(unsigned long) FeatureValue] == nullptr) {

                Feature = new Feature();

                Feature->setValue(FeatureValue);

                seenFeatures[(unsigned long) FeatureValue] = Feature;

            } else {

                Feature = seenFeatures[(unsigned long) FeatureValue];

                Feature->setValue(FeatureValue);

                seenFeatures[(unsigned long) FeatureValue] = Feature;

            }

            registerFeature(Feature);

            delete Feature;

        }



    }

    inputFlash.close();



    return true;

}