If you know both the $V$ and $H$ representations of your original polytope, then each of the two polytopes have vertices given by the original vertices that are all on one side of the hyperplane (i.e. $c \cdot x \leq d$ or $c \cdot x \geq d$), combined with the new vertices given by the vertices of the solution to the combined equations/inequalities $c \cdot x = d$ and $Ax \leq b$.
The $H$ representations are even easier: either $c \cdot x \leq d$ or $c \cdot x \geq d$, combined with $Ax \leq b$.
UPDATE: Per your comment request, I'll review what I know about efficiently getting H-representation from V-representation and vice-versa. First of all, the problem of computing H-representation of a convex hull of a given set of vertices, and computing vertices of a given H-representation are equivalent. To see this, given a set of vertices where you want the H-representation of the convex hull, consider the "dual polytope" defined by the inequalities $v_i \cdot x \leq 1$ where $v_i$ are your original vertices and $x$ are the variables. Then vertices of this dual polytope correspond to normal vectors of facets of the original polytope (full-dimensional faces, defined by a single inequality $x \cdot v \leq 1$ for the H-representation (where $x$ is the normal vector)). Thus if you can find all vertices of the dual polytope then you know a minimal H-representation of the original polytope. To make this work you need to translate your original vertices so that $0$ is in the interior of the original polytope (covex hull), which is easy e.g. if you compute the average of all original vertices and subtract this from all original vertices before forming the dual.
So it all boils down to finding all the vertices of a polytope given in H-representation. There are at least two efficient (well, efficient under their own assumptions) ways to do this.
If the dimension of the polytope is low (e.g. especially dimension 2 or 3 or 4), then probably the best way is to use the so-called beneath-beyond algorithm which you can read about e.g. in the computational geometry book by Edelsbrunner, or perhaps online. It basically maintains the facets (full-dimensional faces) of the convex hull of all vertices found so far, and then for each outer pointing perpendicular vector (normal vector) to a facet, uses linear programming to maximize the dot-product with this vector, over the original H-representation, and either find a new vertex or confirm that the normal vector for the facet defines a true facet of the convex hull, so it doesn't need to be tested anymore. When a new vertex is found, you find the "horizon" of current facets that share the boundary of the exterior of the existing convex hull that can see this new vertex, and extend the one-dimensional-lower faces on the boundary of these facets that contain these vertices to new facets, by adding the new vertex to them, thus updating the convex hull and adding new facets whose normal vectors need to be tested to find more vertices. Eventually no new vertices will be found and then you are done. In low-dimensions, Raymond Seidel's expected linear time linear programming in fixed dimension is the way to go, although the hidden "fixed" constants in fixed dimension for the expected running are exponential in the dimension, so probably only good for dimension around 5 or less. Seidel's algorithm is described in the computational geometry book by Overmars and coauthors, and also probably available online.
Anyway, the other way which is good if the dimension is large is the so-called "compact, output sensitive polynomial time" algorithm by Avis and Fukuda. I don't think any books have this but papers are available online. The idea is that you only maintain vertices and edges of the polytope you are constructing, which has quadratic complexity in terms of the total number of vertices. and then you use polynomial time linear programming that is slower in low dimension than other approaches, but always polynomial time even if the dimension is not fixed (e.g., interior point methods) to repeatedly try to extend the set of known vertices along all possible edge directions, until all vertices are found. This is implemented at
but in low dimensions (especially dimensions 2-4), it probably won't run as fast as the first approach I described.