Is there a standard way to indicate that a function returns a new pointer?
No, there is no "standard way" (but there is an API design policy currently considered "best practice").
Because of this ambiguity ("what does a function returning a pointer want me to do with it?"), it is currently considered best practice to impose the lifetime and ownership policy, through the return type:
<vertex pointer type> new_vertex(const Options& options);
<vertex pointer type> can be
std::unique_ptr ("new_vertex doesn't own the pointer"), or
std::shared_ptr ("client code doesn't own the pointer"), or something else, that has clearly defined ownership semantics (for example,
Vertex const * const would indicate to client code "read the address and values, but change neither/don't delete the pointer").
Generally, you should not return a raw pointer (but in some cases, "practicality beats purity").
TLDR: there is a best practice (yes), but not a standard way (in the language).
where the function is only intended to be used to within a class that owns the Vertex
If the class owns the Vertex, I would write it like this:
class SomeClass // owns the vertex
void do_stuff() // uses the vertex internally
init_vertex(); // see below
// use vertex as needed
// "class owns the Vertex"
// sets the internal vertex
// function doesn't return a pointer of any kind
void init_vertex(const Options& options); // or "reset_", "refresh_",
// or "make_" vertex,
// if the pointer can change
// throughout the lifetime
// of a SomeClass instance