class Actor;
class RigidBody;

struct PhysicsSync {
Actor* actor;
RigidBody* body;
};

class PhysicsSystem {
public:

void Update(float dt)
{
this->CheckCollisions();
for (size_t i = 0; i < sync.size(); ++i) {
sync[i].body->Update(dt); //temp (not updates itself)
sync[i].actor->SetTransform(sync[i].body->BuildTransform()); //temp (not builds itself)
}
} 
void PushSync(Actor* _actor, RigidBody* _body)  
{ 
PhysicsSync target; 
target.actor = _actor; 
target.body = _body; 
sync.push_back(target); 
}

void RemoveSync(Actor* actor, RigidBody* _body)  
{  
//...
}

void ClearSync() { sync.clear(); } 

private: 
void CheckCollisions(); 
std::vector<PhysicsSync> sync; 
};

struct ResponseSync { //collision response
Entity* entity; //assuming that component holds a owner pointer 
RigidBody* 
}

Basically the ResponseSync takes the form of a Event/Message.

What are Actor and RigidBody? Are those components?

This means that there is some outside code that knows specifically about a PhysicsSystem, and more importantly that entities with Actor and RigidBody should be added via PhysicsSystem.PushSync.

Instead, I would think this logic would exist in the PhysicsSystem. e.g. systems in general implement a common interface that has methods for adding/removing entities. When it's called, the PhysicsSystem itself knows that it's interested in entities with Actor and Rigid body, and can then add them to some internal list. That way you don't need outside logic that knows about the PhysicsSystem (other than a single line of code that says, "create a PhysicsSystem and add it to the list of systems") and that it depends on Actor & RigidBody.

1. Yes

2. Was just a simple way of saying...

3. I completely agree with you in that case. Now, following your method, becomes:

class Entity {
public:
template <class T> 
T* GetComponent(const std::string& _id)
{
std::map<std::string, Component*>::iterator it = component.find(_id);
if (it != component.end()) {
return static_cast<T>(it->second);
} else {
return 0;
}
}
};

class PhysicsSystem {
public:
PushComponent(Entity* _entity)
{
Actor* actor = _entity->GetComponent<Actor*>("Actor");
RigidBody* rbody = _entity->GetComponent<RigidBody*>("RigidBody");

if (rbody && actor)  {
PhysicsSync sync(actor, body);
sync.push_back(sync);
}
}
};