Is it possible to pass a variable out of a class without creating a new object in C++

I have a variable, which is a member of one of my classes, that another is in need of, but I'm not sure how to effectively pass the value between them without using a global variable, which is something I'd like to avoid if at all possible. I know I could create an object, but that would invoke the constructor of the originating class which would execute a number of functions and write the needless results to memory, which would be wasteful of system reso开发者_运维知识库urces.

Is there an easy way to pass this value between the two functions?

Update: The class that is in need of the variable, called no_of_existing_devices. The purpose of class Initialise is to open up a file and count the number of lines of test it contains, and place that number in the variable int no_of_existing_devices, which is then used by the Device::Device() to create an object for each

class Device
{   
public:
    void view_attribute_list(); 
    void set_attribute();
    Device();
};

Device::Device()
{
    for (int count = 0; count < no_of_existing_devices; count ++)
    {
    // Create an object for each iteration, up to a maximum of no_of_existing_devices
    }
}

The class of which this variable is a member

class Initialise
{
public:
    int no_of_existing_devices;
    bool initialisation;
    string existing_device_list[100];

    void initialise_existing_devices();
    Initialise();
};

Initialise::Initialise()
{
    no_of_existing_devices = 0;
}

void Initialise::initialise_existing_devices()
{
    string line;
    ifstream DeviceList;
    DeviceList.open("devices/device_list");
    while (true)
    {
        getline(DeviceList, line, '\n');
        if (DeviceList.eof())
        {
            break;
        }
        ++ no_of_existing_devices;
    }
    DeviceList.close();

    DeviceList.open("devices/device_list");
    for (int i = 0; i < no_of_existing_devices; i ++)
    {
        getline(DeviceList, line, '\n');
        existing_device_list[i] = line;
    }

    Device existing_devices[no_of_existing_devices];
    !initialisation; // Existing devices are now initialised
}

Okay, from what I understand:

1. You don't want to have a global
2. You don't want to have a static
3. You don't want to introduce a dependency between Device and Initialise

There is one other option, assuming something owns Device and Initialise, move the no_of_existing_devices up to there, then construct both Device and Initialise with a reference to this variable...

In a similar circumstance I was just passing the pointer to the member --- I had to invoke a member function then, so it was a pointer to the member function, http://www.parashift.com/c++-faq-lite/pointers-to-members.html It's a bit messy, but it works :-).

If the variable in the originating class can hold a value without an instance of the class I would assume that the variable is static. If not create a public static member of the class. And use it in the target class. Something like:

// .h file

class A 
{
   public:
       static int a;
}

// .cpp file

int A::a = 123;

// .cpp file of class B

void B::foo()
{
  cout << A::a;
}

If it is a class attribute (internal variable), then you can obtain a reference through a get method. Otherwise, you can use the friend keyword on the class you want to access the attribtue from the other For example, if you declare friend class B; on class A, the attributes of the class B will be accessible on the class A.

I suggest you use the first method in order to maintain your code OO pure ;)

Edit: of course, if you access through a reference there are no resources wasted :)

Edit 2: use a static method on Initialise class that returns the no_of_existing_devices and call Initialise::NoOfExistingDevices() on the Device class. If you want to resources use a pointer like this:

public static int* Initialise::NoOfExistingDevices() {
    return &no_of_existing_devices;
}

By the way, I advise you to turn the variable private.