Question

I have a compilation basic error.

My main on a nutshell is:

main.cpp

#include "sendArrayObj.h"
sendArrayObj* sendqueue;

void foo(){
    int i = sendqueue->count()
}

int main(){
    int i =10;
    sendqueue = new sendArrayObj(i);
    foo();
}

sendArrayObj.h

using namespace std;
#include <string.h>
#include <string>
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <unistd.h>


class sendArrayObj{
private:
    int size,toEnqueue,toDequeue,lastDequeuedInd;
    unsigned long long totalEnqueued,totalDequeued;

public:
    char** arr;
    int* lengths;
    sendArrayObj(int size);
    void enqueue(string str);
    char* dequeue();
    int count();
    int getDequeuedSize();

};

sendArrayObj.cpp

#include "sendArrayObj.h"

pthread_mutex_t mutex_requestsqueue = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex_count = PTHREAD_MUTEX_INITIALIZER;


sendArrayObj::sendArrayObj( int size){
this->size = size;
toEnqueue = 0;
toDequeue = 0;
totalEnqueued = 0;
totalDequeued = 0;
lastDequeuedInd = -1;
arr = (char**)malloc(size*sizeof(char*));//alloc number of pointers
lengths = (int*)malloc(size*sizeof(int));//alloc number of lengths
}

void sendArrayObj::enqueue(std::string str){
int strSize = str.size();
pthread_mutex_lock( &mutex_requestsqueue );
if (arr[toEnqueue]!= NULL){
    free(arr[toEnqueue]);
    toDequeue = (toDequeue+1)%size;
    totalDequeued++;
}
arr[toEnqueue] = (char*)malloc(strSize);
memcpy(arr[toEnqueue],(char*)str.c_str(),strSize);
lengths[toEnqueue] = strSize;
toEnqueue = (toEnqueue+1)%size;
totalEnqueued++;
pthread_mutex_unlock( &mutex_requestsqueue );
}



char* sendArrayObj::dequeue(){
pthread_mutex_lock( &mutex_requestsqueue );
//allocate memory to the ans 
//char* ans = new char[lengths[toDequeue]];
char* ans = arr[toDequeue];
lastDequeuedInd = lengths[toDequeue];
//memcpy(ans,arr[toDequeue],lengths[toDequeue]);
//if (arr[toDequeue]!=NULL){
    //delete[] arr[toDequeue];
arr[toDequeue] = NULL;
//}
toDequeue = (toDequeue+1)%size;
totalDequeued++;
//printf("totalDequeued is %d\n",totalDequeued);
pthread_mutex_unlock( &mutex_requestsqueue );
return ans;

}



int sendArrayObj::count(){
pthread_mutex_lock( &mutex_count );
int ans = totalEnqueued-totalDequeued; 
pthread_mutex_unlock( &mutex_count );
//printf("count is %d\n",ans);
return ans;
}

int sendArrayObj::getDequeuedSize(){    
return lastDequeuedInd;
}

my compilation batch is

g++ -g -pthread utils/hregex.cpp ExcludeFields.cpp utils/sha1.cpp utils/utils.cpp utils/base64.cpp utils/xmlhelper.cpp utils/messagehelper.cpp utils/safe_queue.cpp utils/parser.cpp utils/default_config.cpp ExcludesParameters.cpp main_process_helper.cpp main.cpp -Iutils -Ibusiness_objects -o telepath_sniff

and the files are in the folder “utils”

Any idea of why I’m getting it??

Thanks

Answer 1

You must tell the linker which object files to link into your application.

edit:

You posted the following command, with readability tweaks by me:

g++ -g -pthread 
utils/hregex.cpp \
ExcludeFields.cpp \
utils/sha1.cpp \
utils/utils.cpp \
utils/base64.cpp \
utils/xmlhelper.cpp \
utils/messagehelper.cpp \
utils/safe_queue.cpp \
utils/parser.cpp \
utils/default_config.cpp \
ExcludesParameters.cpp \
main_process_helper.cpp \
main.cpp -Iutils -Ibusiness_objects -o telepath_sniff

With GNU tools, you put dependencies after what depends on it.

E.g., if main.cpp depends on foobar.cpp, you write

g++ main.cpp foobar.cpp

because the linker will try to link main.cpp, and then keep a list of references that need to be solved later. You ordered it wrongly.

And finally, you are missing sendArrayObj.cpp alltogether.

So,

• put what depends first, and that what it depends upon behind it
• add sendArrayObj.cpp to your build script command

---

Sidenote: You should generally

• use include guards
• avoid global variables
• avoid manual memory management
• not expose writable member variables
• either define copy semantics well or forbid copying alltogether
• not use C headers (e.g. use cstdio, not stdio.h)
• make member functions const if they are not supposed to change the observable state of an instance of your class
• not put using namespace in header files
• prefer standard library containers like std::list or std::vector over dynamically allocated arrays
• write destructors for classes that manage memory
• release memory
• use a consistent indendation scheme
• not include headers you don’t need, this costs you time and therefore money
• use a build system (e.g. makefiles, IDE project files, cmake, Scons)
• get good introductory literature on topics you are a newbie in
• not write projects that big if you have not read good introductory literature, which is doubly triply true of C++