I have 3 classes, A, B and C:

```
class A {  
public:  
 virtual bool sm(B b) = 0; 
 virtual bool sm(C c) = 0; 
};  

class B : public A {  
 bool sm(B b) {
  //code
 }
 bool sm(C c) {
  //code
 }
};  

class C : public A {  
 bool sm(B b) {
  //code
 }
 bool sm(C c) {
  //code
 }
};  

```

And `vector<A*> objects`, that stores B or C objects. (for example they generates randomly)  

Can I call somehow

```
for(int i = 0; i < objects.size(); i++) {
 for(int j = i; j < objects.size(); j++) {
  objects[i].sm(objects[j]);
 }
}

```

Without dynamic cast or something? Because there can be a bit more of B-C classes  

And is it a bag thing, and may be there is a better way to do it? 

**SOLUTION**  

As `odelande` said and I understood, this is the solution for my problem 

```
#include <iostream>
#include <vector>

class B;
class C;

class A {
public:
    virtual bool sm(A* a) = 0;
    virtual bool sm(B* b) = 0;
    virtual bool sm(C* c) = 0;
};

class B : public A {
public:
    bool sm(A* a) {
        return a->sm(this);
    }
    bool sm(B* b) {
        std::cout << "In B doing B" << std::endl;
        return true;
    }
    bool sm(C* c) {
        std::cout << "In B doing C" << std::endl;
        return false;
    }
};

class C : public A {
public:
    bool sm(A* a) {
        return a->sm(this);
    }
    bool sm(B* b) {
        std::cout << "In C doing B" << std::endl;
        return true;
    }
    bool sm(C* c) {
        std::cout << "In C doing C" << std::endl;
        return false;
    }
};

int main() {
    std::vector<A*> objects;
    objects.push_back(new B());
    objects.push_back(new C());
    objects[0]->sm(objects[0]);
    objects[0]->sm(objects[1]);
    objects[1]->sm(objects[0]);
    objects[1]->sm(objects[1]);
    std::cin.get();
    return 0;
}

```

This code outputs 

> 
> In B doing B  
> 
>  In C doing B  
> 
>  In B doing C  
> 
>  In C doing C
> 
> 
>