autoconf gives you a config.h, which provides string macros such as PACKAGE, PACKAGE_NAME, PACKAGE_STRING, PACKAGE_VERSION, and VERSION.

(When I use the Argp argument parser, I simply use

#ifdef HAVE_CONFIG_H
# include <config.h>
#endif
#include <argp.h>
const char *argp_program_version = PACKAGE_STRING;
const char *argp_program_bug_address = PACKAGE_BUGREPORT;
/* et cetera */
int main(int argc, char **argv) {
    error_t argp_result = argp_parse(&argp, argc, argv, 0, 0, NULL);
    if (argp_result) return argp_result;
    /* et cetera */
}

and then --help, --version, etc. just automatically work.)

You could also add

AC_CANONICAL_HOST
AC_DEFINE_UNQUOTED([CHOST], ["$host"], [Canonical host])
AC_CANONICAL_BUILD
AC_DEFINE_UNQUOTED([CBUILD], ["$build"], [Canonical build])
AC_CANONICAL_TARGET
AC_DEFINE_UNQUOTED([CTARGET], ["$target"], [Canonical target])

to your configure.ac, if you want to have those string macros in your config.h too. These are typically strings of the form $arch-$vendor-$kernel-$libc, where
CHOST is the platform that will run the software after it is built,
CBUILD is the platform that is currently building the software, and
CTARGET is the platform the software will act on.
(These are all the same unless you are cross-compiling or building a cross-compile toolchain.)

Write a python script that generate your version source file. Then make it run by whatever build scripts/tool you re using.

Choose a rule to actually rewrite the version file and enforce it in the python script : it s really dependent on the type of project and release organisation you re doing.

In my home project I use a script that generate a version file each time I build, because I need to know wich computer-developer built the version and at wich time.

But in a lot of job works I used a script that generated the version file but only if I wanted it to. That s because the dev team decided when a specific version was a "release".

I suggested using a Python script because Python runs on all developement platforms and is really powerful and easy when it comes to text files manipulations. It can then be called by whatever build system (Visual Studio, CMake, etc.) you use.