Classes access other classes local variables

Lets say I have a header file that declares a class, I have another header file that declares another separate class so now we have Class1 and Class2 who have no contact with one another. Class2 gets ballsy and wants to access local variables from Class1 how is this done exactly? Or should I rework the framework of my program?

Class1 should have a public GetSomething() function which returns its member variable. If you only want to make these local variables available to Class2 (and no other classes), then you can make Class2 a friend of Class1.

First of all if u are saying that you want to access private variable of a class (local u said), there are numerous ways to do that....

1... make the class as friends to each other.
2... Make an object of a class and call there property function which we say get / set functions
3... Another one which i can tell u is not in the books u will find, as it is having some restrictions as well.

Code:

#include <stdio.h>

class Test {
private:
  int a;
  int b;

public:
  inline void show() {
    printf("a == [%d] || b ==[%d]\n", a, b);
  }
};


int main() {
  Test obj;
  int* ptr = (int*)&obj;
  *ptr = 10;
  ++ptr;
  *ptr = 20;
  obj.show();
  return 0;
}

sample code output

Code:

[rocky@localhost cpp]$ g++ test.cc
[rocky@localhost cpp]$ ./a.out 
a == [10] || b ==[20]
[rocky@localhost cpp]$

If Class1 has not provided some specific means to allow Class2 to access its members (eg making them public, declaring Class2 as a friend, some employment of the visitor pattern) there is no way that Class2 can force the issue without relying on non-standard (eg compiler specific) hacks.

If by "ballsy" you mean that Class1 has not provided such access, then you can't.

Unfortunately i'm not sure how to implement this so i'll draw out how I interpret it:

Class1.h

Code:

#ifndef _CLASS1_
#define _CLASS1_

#include "RandomAudioFramework.h"

class Class1 {
public:
     RandomAudioFramework *mRandomAudioFramework;

     DoSomethingWithFramework();
     RandomAudioFramework ReturnClass1LocalFramework();
}

#endif

Class1.cpp

Code:

#include "Class1.h"

void DoSomethingWithFramework() {
     mRandomAudioFramework->PlayBeep();
}

RandomAudioFramework RetrunClass1LocalFramework() {
     return *mRandomAudioFramework;
}

Class2.h

Code:

#ifndef _CLASS2_
#define _CLASS2_

#include "Class1.h"

class Class2 {
     EditClass1Variable();
}

#endif

Class2.cpp

Code:

#include "Class2.h"

void EditClass1Variable() {
     ReturnClass1AudioFramework().Volume = 0;
}

main.cpp

Code:

#include <stdio.h>
#include "Class1.h"
#include "Class2.h"

void main() {
     Class1 *class1 = new Class1;
     Class2 *class2 = new Class2;
     class2->EditClass1Variable();
     return 1;
}

Now i've been programming objective-c for the past few days so remembering how to call things in Cpp is for somereason harder than usual but I think the gyst is there. I want to create Class1 and Class2 and have Class2 access Class1... I hope this makes sence

Since all your members of Class1 are public, you don't have a problem.

The only caveats are that Class2's EditClass1Variable needs to be implemented as

Code:

Class2::EditClass1Variable() {
     some_particular_object_of_type_Class1.mRandomAudioFramework->Volume = 0;
}

If you want to use Class1's ReturnClass1LocalFramework() member function, then that function needs to return a reference, not an object. In other words;

Code:

class Class1
{
   public:
      //other stuff

    RandomAudioFramework &ReturnClass1LocalFramework() {return *mRandomAudioFramework;};

};

This assumes, of course, that it makes sense for Class1 to allow other classes (eg Class2) unfettered abilities to modify its members. In practice, such things often represent poor design.

Know that you can create the variables on the stack rather than the heap, too.
You'll have to delete the variables that you allocate in your example, but you don't.
Making them stack variables solves that.