Thread: call methods across classes

Code:

class A
{
     void foo()
     {

     }
};

class B
{
     void bar()
     {

     }
};

Is there a possibility I can call foo() from bar() without creating objects.

Restrictions: * Cannot use static methods
* Cannot create class Hierarchies
* Cannot use Friend Functions

Since foo() is private, nobody can call it except class A.

Originally Posted by cpjust

Since foo() is private, nobody can call it except class A.

I think the failure to make it public was just an oversight on the OP's part.

The other folks are right. In order to call a non-static member function, you must have an instance of the class. A non-static member ALWAYS is associated with an object. If you have no object, you have no member function.

aforementioned code snippets do not regard the restrictions ... I dont want to create objects of A

I was thinking in terms that ... since member functions are not saved on per instance basic... they might have been allocated some area of memory during loading of the class

So what if I could use a pointer to member function to save that address and use it to invoke a call to foo() from bar() ... without creating object for A

ofcourse I would need an object for B to call ... but I am allowing that

and I forgot to mention ... yeah the member functions can be public

Code:

#include<iostream>
using namespace std;

class A;

void (A::*p)() = NULL; 

class A
{
      public:
             
      void foo()
      {
           cout<<"A";
      }
};

class B
{
     public:
            
      void bar()
      {
           p = &A::foo;
           A a;                     // I dont want to create object of A
           (a.*p)();               // calling requires object
      }
};

int main()
{
    B *b = new B();
    b->bar();
    cin.get();
}

You need an instance to call a non-static member.

Code:

void foo() {
  std::cout<< "A::foo() method called\n";
}

class A {
private:

public:

};

class B {
private:

public:
  void bar( void ) {
    foo();
  }

};

/* ... */

int main( void ) {
  A a;
  B b;

  b.bar( a );

  return 0;
}

Why not just have it as a separate function?
It seems to me that if you want to be able to call a function within class two but not have an instance of class one from which to call it the function doesn't need to be in class one at all.

There's basically just 2 options.
1. If foo() needs access to any non-static members of class A, then you MUST create an instance of A.
2. If foo() doesn't need access to non-static members of class A, then it should be static, which would allow you to call it without creating an instance of A.

Code:

class A
{
public:
    static void foo();
};

Originally Posted by Bubba

Please do not do this. Standard C++ provides plenty of safe valid mechanisms for your purposes.

If you read my post again, you'll see I was certainly not advocating doing this.

Given the requirements stated in the original post (calling a non-static member of a class without having an instance of that class), the only possible solutions invoke some form of undefined behaviour -- which is something I never advocate as it is not in the category of "safe valid mechanisms". But, it is appropriate to note the technical possibility -- particularly one that is actually employed within implementations of standard libraries associated with some well known compilers (compiler vendors are allowed to implement a specific interpretation of any form of undefined behaviour).