Make everything as private as possible. For example, just because an OBJMesh instance needs export_params, that doesn't mean that other code should be able to access & modify those.

Add a _ suffix to the private names.

me_eval is a very generic name. Probably export_mesh_eval is better.

coords is an output parameter, so prefix the name with r_. Same for other functions.

There is no need to declare these variables. It makes it harder to understand the rest of the code in this function.

Instead of looping over all layers, just use CustomData_get_layer(&me_eval->ldata, CD_MLOOPUV) to get the layer you need.

I think this can be cleaned up by using a few extra variables, and by using an implicit construction of the std::array<float, 2>:

const int loopstart = mpoly[uv_vert->poly_index].loopstart;
const float[2] vert_uv_coords = mloopuv[loopstart + uv_vert->loop_of_poly_index];
uv_coords.push_back({vert_uv_coords[0], vert_uv_coords[1]});

Indices are 0-based or 1-based (indicating the index of the first element). The total number of vertices cannot be 0-based or 1-based.

I don't understand why there is a need to keep tot_uv_vertices around. It should be the same as uv_coords.size(), right?

Don't use designated initialisers. It works in some cases, on some compilers, but it's not part of the C++ standard.

What are "curve-like meshes"?

Don't index multiple times, just store me_eval->mvert[(mloop + i)->v] in a temporary variable.

I don't understand what is happening here. There is no curve, just a mesh. And it doesn't check for any "this is cyclic" flag.

Here object changes semantics, from "original object" to "evaluated object". This should not be done with the same name, as you can then never be sure what it points to (unless you really trace all the possible calls to get_mesh_eval() and compare that with all the uses of objmesh->object, which you don't want).

object is a very generic name to use. Something more explicit like export_object_eval is better.

I also doubt that this is the right place for setting that property. After all, the OBJMesh() cannot work without having an object to export, or without its export parameters. This means that these should be passed to the constructor instead.

Naming: Make a distinction between "mesh" and "mesh writer for the OBJ format". export_mesh reads like it's a mesh, but it's not.

Use LISTBASE_FOREACH or ListBaseWrapper.

See comment above: the OBJMesh can't do its work without these, so just pass them to the constructor.

This accesses many internals of OBJMesh, indicating that this functionality should actually be moved into a member function of OBJMesh.

Avoid comments that repeat the function declaration.

Avoid comments that repeat the function declaration.

This should either be done in the destructor, or at least the class should have a destructor that calls this function if necessary.

The code below can probably be simplified to something like this:

for (uint i = 0; i < ob_mesh.tot_poly_normals; i++) {
  ob_mesh.calc_poly_vertex_indices(vertex_indices, i);
  if (ob_mesh.export_params->export_normals) {
    ob_mesh.calc_poly_normal_indices(normal_indices, i);
  }
  const MPoly &poly_to_write = ob_mesh.me_eval->mpoly[i];

  ...
}

The code on the ... could also be simplified if you give the four write_vert_..._indices() functions the same signature. Once you've done that, you can use a pointer to the appropriate function (based on the export_normals and export_uv params) and call that within the loop.

This is not something pressing, but could be done if you have some spare time ;-)

This is C++, use an enum class instead.

Same as with OBJWriter, make everything as private as possible.

Clarified it: curves converted to meshes when export_curves_as_nurbs is false.

When a curve is converted to mesh, it doesn't have any cyclic flags anymore. So I thought me_eval->totvert == me_eval->totedge is a good test for cyclicality. When cyclic, last edge connects to the first edge, otherwise it's open ended.

Should I put the init_writer() in constructor and use exceptions to catch if the file opening failed ?