No estoy muy seguro, pero ¿y si haces flush?

std::string fullMessage;
fullMessage = ArrayToString(data);
cout << fullMessage; 
cout.flush();
system("pause");

Ya digo que no sé si estoy diciendo alguna tontería

La función 'vacío' se puede hacer más sencilla:

bool funciones::vector_vacio(vector_n V){
    for(int i = 0; i < V.n; i++) {
        if(0 != V.elementos[i])
            return false;
    }
 
    return true;
}

A parte de eso, en la función 'media' hay varios errores:

double funciones::media(vector_n V){
    double resultado = 0.0;
    int i;
 
    for(i = 0; i < V.n; i++)
        resultado += V.elements[i];
 
    if(0 == V.n) {// Damos el error
        printf(stdout, "Error. Se ha intentado calcular la media de un conjunto vacío.\n");
        return 0.0;
    } else {
        return resultado / (double)V.n;
    }
}

No me fijé en eso antes. Si quieres acceder a las funciones de una estructura de forma estática, primero, en la estructura, tienes que definirlas como estáticas:

struct funciones {
    static void carga_arreglo(arreglo V);
    static double media(arreglo V);
    static double varianza(arreglo V);
    static double desv_est(arreglo V);
};

Definirlas de forma estática le dice al compilador que esos métodos (funciones dentro de una clase/estructura) no modificarán ningún miembro del objeto.

Una vez declaras las funciones como estáticas, puedes usarlas así:

funciones::carga_arreglo(arreglo);

Si nos guiamos por el ejemplo dado por AlbertoBSD, el argumento sería el vector. Es decir, puedes hacer esto:

funciones.carga_arreglo(arreglo);

Solo quería aclarar que creo que hay algunos pequeños errores en el código de AlbertoBSD. Creo que este sería el código bueno (puede que me equivoque):

#include<stdio.h>
#include<math.h>
#include "Calculos_estadisticos.h"
 
void funciones::carga_arreglo(vectorN &V) {// Si no lo pasas por referencia, no afectará al vector.
    int z = V.n; // Aquí antes estaba vectorN.n, pero lo que quieres hacer es acceder al miembro de 'V'
    for(int i=0; i<z; i++){
        scanf("%d",&vectorN.elementos[i]); // Aquí tienes que poner los corchetes para acceder a cada elemento
    }
}

Creo que se refería al fragmento de código que proporcioné. Puse en código pensando en C, porque no caí en la cuenta de que el usuario está trabajando en C++. Entonces, antes de la función calloc yo tendría que haber puesto (int *)

Claro. Estás trabajando en C++. En C++, el casteo de tipos es más estricto. Mientras que en C ese código no produciría errores, en C++ tienes que castear el retorno de la función (tienes que poner int * porque calloc retorna el tipo void *).

Básicamente, C++ es más estricto en esas situaciones

Si lo que quieres hacer es declarar un tipo de variable que almacene un vector de n elementos, podrías crear la siguiente estructura:

typedef struct {
    int *elementos; // Este puntero apuntará al primer byte del vector
    unsigned int n; // Esta variable almacenará cuantas dimensiones tiene el vector
} vectorN;

Entonces, una vez tenemos esa estructura, cuando obtengamos del usuario las dimensiones que quiere para su vector, solamente rellenamos la estructura:

#include <stdlib.h>
#include <stdio.h>
 
int main() {
    vectorN vector = {NULL, 0};
 
    fprintf(stdout, "Introduzca las dimensiones que quiera para su vector: ");
    fscanf(stdin, "%u", &vector.n);
    vector.elementos = calloc(vector.n, sizeof(int));
 
    return 0; // No olvides liberar la memoria cuando termines!
}

También podrías crear una función que te haga el trabajo:

#include <stdlib.h>
#include <stdio.h>
 
void init_vectorN(vectorN *vector, unsigned int n);
 
int main() {
    vectorN vecto = {NULL, 0};
    unsigned int n;
 
    fprintf(stdout, "Introduzca las dimensiones que quiera para su vector: ");
    fscanf(stdin, "%u", &n);
    init_vectorN(&vector, n);
 
    return 0;
}
 
void init_vectorN(vectorN *vector, unsigned int n) {
    vector.n = n;
    vector.elementos = calloc(n, sizeof(int));
}

No sé a que te refieres con ciclos 'void'. Supongo que refieres a recursividad... En tal caso, podrías hacer esto:

void puntos(int j) {
    if(j >= 1) {
        printf ("que tal"); //que repita "que tal" una x cantidad de veces
        puntos(j - 1);
    }
}

Aunque este código funcione, es mejor usar un ciclo 'for' o 'while'...

Ups. No consideré el tamaño del arreglo... qué despiste el mío XDD Gracias por la aclaración

En 32 bits sí que sería lo mismo XDD

En 64 bits no, pues la primera se incrementa en 4 y la segunda en 8

Gracias