Hola!
Acá puedes usar el concepto de "friends" (https://isocpp.org/wiki/faq/friends)

Una cosa espantosa puede ser algo así...

#include <iostream>
 
//ClaseB
class ClaseB {
    friend class ClaseA;
public:
    void Beta(class ClaseA* a);
};
 
//ClaseA
class ClaseA {
private:
    ClaseB* b;
    bool hecho = false;
    friend class ClaseB; // https://isocpp.org/wiki/faq/friends
 
public:
    ClaseA() : b{ new ClaseB } {}
    ~ClaseA() { delete b; }
    void Alpha();
 
};
 
 
//ClaseA fuente
void ClaseA::Alpha() {
    //hacer algo
    if (hecho)
        return;
    b->Beta(this);      //invoco a ClaseB::Beta()
    std::cout << "Alpha";
    hecho = true;
}
 
//ClaseB fuente
void ClaseB::Beta(class ClaseA* a) {
    //el hilo proveniente de ClaseA::Alpha pasa por aqui...
    //hacer algo
    //invocar de vuelta a ClaseA::Alpha() desde un principio...
 
    if (a->hecho)
        return;
    a->hecho = true;
    std::cout << "Beta";
    a->Alpha();
}
 
// Lo que busco hacer es llamar desde ClaseA::Alpha() a ClaseB::Beta(), luego ClaseB::Beta() debe invocar a ClaseA::Alpha() de vuelta.
 
int main()
{
    ClaseA a;
    a.Alpha();
 
}

Una más...

int arreglo[ cantidad ];

error C2131: expression did not evaluate to a constant arm64 msvc v19.latest

cantidad no es constante, lo que hace que esta no sea una expresión válida C++.
Es válida en C99, pero no lo es no lo fue nunca en C++.

Se trata de VLA "Variable Length Array" (array de longitud variable). Algunos compiladores lo implementan como una extensión al lenguaje pero otros no, por ejemplo del del Visual Studio...

Hola, creo que te facilitará la idea si consideras que en

template <typename T>
void my_function ( T _param);

T es el tipo del parámetro _param, o lo que es lo mismo: "el tipo de _param es T"; como cuando se tiene int i = 5; decimos que el tipo de i es int, o que i es de tipo int. (Fíjate que le he dado la vuelta a la forma en que lo dices).

Cuando se tiene int* p; se dice que p es de tipo int* (Como el C++ está más centrado en tipos que el C, es por eso que se prefiere escribir int* p en lugar de int *p).

En el ejemplo de acá abajo, la función genérica f tiene un parámetro t de tipo T*. Creo que al decirlo de esta manera se percibe más claramente la idea.

#include <iostream>
#include <typeinfo>
 
template<typename T>
void f(T* t) {
    std::cout << "type: " << typeid(t).name() << '\n';
}
 
int main()
{
    int* p = new int(6);
 
    f<int>(p);  // en esta funcion el tipo de t es "int*". 
    f(p);       // es lo mismo ("Template argument deduction")
 
    f<int*>(&p); // en esta segunda funcion el tipo de t es "int**"
    f(&p);       // es lo mismo ("Template argument deduction")
 
    std::string str = "hola";
    f(&str);
}

Fue mi error, std::numeric_limits está en <limits>

Acá va un ejemplo donde se muestra la capacidad de representación como número decimal en punto flotante de un float, double o long double que garantiza el lenguaje:

#include <iostream>
#include <iomanip>
#include <limits>
#include <string>
 
int main()
{
    std::streamsize p_inicial = std::cout.precision(); // precision inicial
    std::cout << "precision inicial = " << p_inicial << "\n\n";
 
    std::string s = "2.99999999999999999999999999999";
    std::cout << "s = " << s << '\n';
 
    std::cout << std::fixed;
 
    float f = stof(s);
    std::cout << "float " << f << '\n';
    std::cout << std::setprecision(std::numeric_limits<float>::digits10-1); // -1 para la cantidad de decimales
    std::cout << "float: " << std::numeric_limits<float>::digits10 << " digitos significativos.\n";
    f = stof(s.substr(0UI64, std::numeric_limits<float>::digits10+1)); // +1 por el punto decimal
    std::cout << f << "\n\n";
    std::cout << std::setprecision(p_inicial);
 
    double d = stod(s);
    std::cout << "double " << d << '\n';
    std::cout << std::setprecision(std::numeric_limits<double>::digits10-1);
    std::cout << "double: " << std::numeric_limits<double>::digits10 << " digitos significativos.\n";
    d = stod(s.substr(0UI64, std::numeric_limits<double>::digits10+1));
    std::cout << d << "\n\n";
    std::cout << std::setprecision(p_inicial);
 
    long double ld = stold(s);
    std::cout << "long double " << d << '\n';
    std::cout << std::setprecision(std::numeric_limits<long double>::digits10 - 1);
    std::cout << "long double: " << std::numeric_limits<long double>::digits10 << " digitos significativos.\n";
    ld = stod(s.substr(0UI64, std::numeric_limits<long double>::digits10 + 1));
    std::cout << ld << "\n\n";
    std::cout << std::setprecision(p_inicial);
}
 
 

Cada compilador implementa los tipos de punto flotante más o menos igual, aunque hay algunas peculiaridades (como el Visual Studio, que usa la misma representación para double que para long double).

Pueden ver en std::numeric_limits<T>::digits10
https://en.cppreference.com/w/cpp/types/numeric_limits/digits10

Por ejemplo:

#include <iostream>
#include <numeric>
 
int main()
{
    std::cout << "cantidad de digitos que pueden representarse sin redondeos ni desbordamiento :\n";
    std::cout << "float: " << std::numeric_limits<float>::digits10 << " digitos significativos.\n";
    std::cout << "double: " << std::numeric_limits<double>::digits10 << " digitos significativos.\n";
    std::cout << "long double: " << std::numeric_limits<long double>::digits10 << " digitos significativos.\n";
}
 

¿hay una manera de saber la memoria que liberaste con free()?

No.

La forma y la cantidad de memoria asignada con malloc, calloc o realloc depende exclusivamente de tu compilador ("implementation defined"). Algunos compiladores suelen asignar un bloque de memoria mayor al que estrictamente se necesitaría, para poder disponer de información de cuánta memoria dinámica deberá liberar free().

Por ejemplo, un método frecuente en algunos compiladores es escribir primero datos sobre el tamaño, un checksum, un par de punteros a los bloques anterior y siguiente, algún marcador. y alguna cosa más, y a continuación los bytes que se solicitaron como múltiplos de 16 (a modo de optimización).

En tu ejemplo sería: primero calloc busca memoria para esa estructura de datos más la cantidad num * sizeof(int) de bytes a alojar como múltiplo de 16 (si necesita alojar 10 int, digamos 40 bytes, agregará 48 = 16*3).

Luego, la dirección devuelta por calloc es la dirección donde comienzan esos datos iniciales, no donde comienza la serie de ints.

Pero como te decía, el mecanismo real depende de cada compilador, de modo que lo que funcione para el tuyo no necesariamente funcionará para otro.

Te paso una: en C++ no se puede llamar a main()

Bueno, no, no está bien.


(1) debería llamar la atención
(2) es un error.

En este caso tu profesor te pide que uses una función de biblioteca para mostrar en la consola una distribución de ciertos caracteres en una determinada disposición. No es un problema específico del lenguaje C, es un problema específico del uso de alguna función de biblioteca en particular, un juego de caracteres en particular y una consola en particular.

Por ejemplo, tu caso es estudiar cómo funciona y cómo se usa printf(), con un juego de caracteres específico sobre una consola en particular. Ni el juego de caracteres ni la consola que estés usando tienen nada que ver con el lenguaje C. El lenguaje C tiene que ver sólo con printf(), el resto es hojarasca del entorno.

Si puedes cambia de profesor.

Si, si estás en windows tendrás que usar Cygwin