Q:

Best way to declare member functions in a hpp file that point to an existing memory address

Due to changes in the MVSC x86/x64 compiler, I cannot use __asm(jmp addr) to perform direct functions via the memory address in the project.
For non-member functions, this Q&A did the trick: replace inline assembly tailcall function epilogue with Intrinsics for x86/x64 msvc
But for member functions, I now need an alternative; it must be pointed out that this is also required for constructors and deconstructors, as well as for functions of the same name for which my variant does not work. Of course, suggestions for improvement are also welcome, and yes, I only have the memory address, so there is no other way to call it up.
zstring.hpp:
#pragma once

#include <string>
#include "../asmjmp.h"

int __cdecl operator==(class zSTRING const &, char const * const);
int __cdecl operator==(class zSTRING const &, class zSTRING const &);

class zSTRING
{
public:
    zSTRING() {
        __asm( jmp 0x00402AF0);
    }

    zSTRING(zSTRING const &) {
        __asm( jmp 0x00416500);
    }

    ~zSTRING() {
         __asm( jmp 0x00401160);
    }

   int Overwrite(unsigned int, class zSTRING const &) {
        __asm( jmp 0x0046B6A0);
    }

    int Overwrite(string) {
        __asm( jmp 0x0046B6FF);
    }

    int Insert(unsigned int, class zSTRING const &) {
        __asm( jmp 0x0046B400);
    }

    /* My Variant: */
    int (*Insert)(unsigned int, class zSTRING const &) = ((int(*)(unsigned int, class zSTRING const &))0x0046B400);

    int Delete(class zSTRING const &, enum zTSTR_KIND) {
        __asm( jmp 0x0046BCF0);
    }

    /* My Variant: */
    int (*Delete)(class zSTRING const &, enum zTSTR_KIND) = ((int(*)(class zSTRING const &, enum zTSTR_KIND))0x0046BCF0);

    char * ToChar() const
    {
        __asm( jmp 0x004639D0);
    }

    zSTRING Copied(unsigned int, unsigned long) const
    {
        __asm( jmp 0x0046C170);
    }

    zSTRING &operator+=(char const *) {
        __asm( jmp 0x0067A7B0);
    }

    /* My Variant (without knowing if it would work): */
    zSTRING (*&operator+=)(char const *) = ((zSTRING (*)(char const *))0x0067A7B0);

    char & operator[](unsigned int) {
        __asm( jmp 0x00445A20);
    }

    /* My Variant (without knowing if it would work): */
    char & (operator[])(unsigned int) = ((char &(*)(unsigned int))0x00445A20);
};

A:

if you want that some function containing single jmp instruction to some address - you need declare it with __declspec(dllimport) (this is Microsoft Specific and work only for CL compiler but think another compilers have equvalent syntax). say for example 
void __declspec(dllimport) TrimLeft(char);

in case you ned this for all member functions in class - declare all class with this:
class __declspec(dllimport) zSTRING
{
    zSTRING();
    // .. more declarations
};

this will have effect on all not virtual member functions and static data member for class like it declared with __declspec(dllimport)
when function declared with __declspec(dllimport) compiler declared extern pointer variable:
extern void* __imp___FUNCDNAME__;

where __FUNCDNAME__ is decorated name of function + __imp_ prefix; and every time when you call such function compiler generate call __imp___FUNCDNAME__ instruction (after pass function arguments to registers or stack). with Edit and Continue options compiler usually generate less optimized code:
call func
func:
jmp __imp___FUNCDNAME__ ; exactly what you try - single jmp in function body

which is by fact equivalent to single call __imp___FUNCDNAME__
now obvious that for every imported functions void* __imp___FUNCDNAME__ must be somewhere defined and containing real function address. otherwise you got well known linker error LNK2001: unresolved external symbol
usually we use LIB file where exactly defined __imp___FUNCDNAME__ symbols - in this case linker put all this __imp_* variable in IAT section of PE and describe it in import section. as result loader assign correct address for every __imp___FUNCDNAME__ when load your image.
if you try import this functions from some DLL and this DLL export this functions - you must have LIB file for this. even if you have no LIB - you can easy create you yourself - create separate project with output file name exactly match to dll name from which you will call code and "implement" all this functions with __declspec(dllexport) for every single function or class. implementation of every function -  can be empty or single return 0; - really when we build lib - it not containing any code (as result implementation can be fake/empty). it containing exactly function names and dll name (because this output file name for project must be exactly dll name. but say project target - exe or dll - does not matter). in general - this must look like:
void __declspec(dllexport) TrimLeft(char)
{
}

class __declspec(dllexport) zSTRING
{
public:
    zSTRING()
    {

    }

    int Overwrite(unsigned int, class zSTRING const &)
    {
        return 0;
    }
    //...
};

you easy build this code and got LIB file (import library) all what you need.
in case this functions not exported - unclear from where you got addresses, but in any case - this can not be hard-coded absolute addresses. you can in extreme case use hard-coded RVA from DLL... in any case if this functions not exported - you need yourself define all __imp___FUNCDNAME__ yourself. and yourself assign correct function addresses for it at begin.
because __FUNCDNAME__ usually containing illegal for C/C++ symbols - you will be need declare it in asm, something like:
_BSS segment

__imp_?TrimLeft@@YAXD@Z DQ ?
__imp_??0zSTRING@@QEAA@XZ DQ ?
__imp_??1zSTRING@@QEAA@XZ DQ ?
__imp_??0zSTRING@@QEAA@AEBV0@@Z DQ ?
__imp_?Insert@zSTRING@@QEAAHIAEBV1@@Z DQ ?

public __imp_?TrimLeft@@YAXD@Z
public __imp_??0zSTRING@@QEAA@XZ
public __imp_??1zSTRING@@QEAA@XZ
public __imp_??0zSTRING@@QEAA@AEBV0@@Z
public __imp_?Insert@zSTRING@@QEAAHIAEBV1@@Z

_BSS ends

and implement function for resolve import yourself
resolveimport proc

    lea rax,[rcx + rva_1]
    mov __imp_?TrimLeft@@YAXD@Z,rax

    lea rax,[rcx + rva_2]
    mov __imp_??0zSTRING@@QEAA@XZ,rax

    ;...

    ret

resolveimport endp

say you call resolveimport from c++ code with address of dll - resolveimport(LoadLibraryW(L"my.dll"));

