Thread: Strange error with class members

Hi. I have a very strange problem in my project that is the lost of values in some variables of some classes. I'm using MinGW that comes with CodeBlocks 10.0.5. I didn't post the code, because my code is very large and I believe that my problem can be more comprehensive if I only show code to ilustrate what is happening. In my project, I have a base class that contains many derived classes, like below:

Code:

class Base_Class{
public:
any functions
A a;
B b;
C c...
};

The derived classes have a pointer to base class:

Code:

class A{
public:
any functions

private:
Base_Class* base_class;
other private members
};

Sometimes, a variable of an derived class "loses" your value. Like below:

Code:

class A{
public:
void load_image();
void display_image();
void set_path_image( int new_path_image );
int get_path_image();

private:
Base_Class* base_class;
string path_image;
};

void A::load_image(){
path_image = get_path_from_dialog();
}

void A::display_image(){
show_image( path_image );
}

void A::set_path_image( int new_path_image ){
path_image = new_path_image;
}

int A::get_path_image(){
return path_image;
}

Inside of function load_image, path_image receive the correct value. But, when its exit of function, it loses this value. Then, in function display_image() your value aren't more correct. This happening with variables of other types, like vectors and strings, but not happening with all variables, only with some. My solution is build other class and insert the variable. But this is very awkward and makes the code confusing. This happening in other classes too, but in a lower frequency. Please, help me and sorry for my bad english.

Originally Posted by lcecil

I have a base class that contains many derived classes, like below:

This does not make sense to me, unless you are saying that the derived classes are not derived from Base_Class, in which case the fact that they are derived classes does not appear significant in this context. Furthermore, in your example, A is not derived from Base_Class.

Post the smallest and simplest compilable program that demonstrates the problem.

Originally Posted by lcecil

What I meant by "derivatives" are classes that belong to the class mentioned.

What you really mean are "member variables", "data members", "properties" or "attributes" of class type. "Classes that belong to the class" sound more like nested classes.

Here's your code in one file so it's easier for someone to copy/paste/run. Note the small change in main to get it to compile.

It seems to run. What exactly is the problem?

Code:

#include <iostream>
#include <deque>

class A;

class B{
public:
    B();
    std::deque<int>& get_test_variable();
    std::deque<int>::iterator& get_iterator_test_variable();
    void set_test_variable_2( int new_test_variable_2 );
    int get_test_variable_2();
    void set_a( A* new_a );
    A* get_a();

private:
    A* a;
    std::deque<int> test_variable;
    std::deque<int>::iterator iterator_test_variable;
    int test_variable_2;
};


//Description:This file contain the implementation of class B.
//Name of class:B
//Way to use:Declare a instance in class A.

B::B(){
}

std::deque<int>& B::get_test_variable(){
    return test_variable;
}

std::deque<int>::iterator& B::get_iterator_test_variable(){
    return iterator_test_variable;
}

void B::set_test_variable_2( int new_test_variable_2 ){
    test_variable_2 = new_test_variable_2;
}

int B::get_test_variable_2(){
    return test_variable_2;
}

void B::set_a( A* new_a ){
    a = new_a;
}

A* B::get_a(){
    return a;
}


class A{
public:
    A();
    void initialize_class_composed();
    B b;
};


//Description:This file contain the implementation of class A.
//Name of class:A
//Way to use:Declare a instance of this class in beginning of app, in main.cpp.

A::A(){
    initialize_class_composed();
}

//Name of funcion:void A::initialize_class_composed()
//Description:Initialize classes members of this class.
//Way to use:This function might be called in constructor of this class.
//Observations:None.
void A::initialize_class_composed(){
    b.set_a( this );
}


std::deque<A*> tests_objects;

int main() {
    A a = A();
    tests_objects.push_back( &a );
    (*tests_objects.begin())->b.set_test_variable_2( 2 );
    (*tests_objects.begin())->b.get_test_variable().push_back( 5 );
    return 0;
}

Doing this

x.push_back( &A() );

creates a temporary variable of type A, which you then take the address of and store in the deque. But after that statement, the temporary A variable NO LONGER EXISTS, so dereferencing the address is undefined bahavior WHETHER OR NOT YOU GET A SEGFAULT. You will not always get a segfault.

You need to set your compiler's warning level higher. Add -Wall to your compiler command line (assuming you're using gcc). Then you will be warned about such things.

Now you've changed the code. That code should work (assuming a proper copy constructor) since you are passing a copy of the A variable, not just its address.

To reiterate what laserlight said earlier:
"Post the smallest and simplest compilable program that demonstrates the problem."

You still haven't done that since now you're saying that the example code you posted does NOT demonstrate the problem.

Create some example code (in a single file) that demonstrates the REAL problem. If you can't do that then you need to make the entire code available.

If those are my options, I'll choose CodeBlocks.