En primer lugar, ningún lenguaje se merece tales palabras, y menos, en un foro de programación.


Efectivamente, Unity se puede programar en C#, y es bastante simple. Si lo que buscas es una manera de hacer interactuar rápidamente elementos 3D con programación, Unity es una posibilidad. Además, tiene una comunidad muy amplia y un montón de ejemplos por ahí con los que no tendrás problema en empezar.


Sobre OpenGL, DirectX, Vulkan: son API que te proporcionan todo lo necesario para 3D (entre otras muchas cosas). Pero son de bajo nivel: tendrás que ver muchas cosas antes de empezar a hacer algo productivo. Si tu idea es pasar rápido a la acción, no son una opción. Si tu idea es dedicarte a algo relacionado con 3D (orientado a programación, no a diseño), ya sea como oficio o como hobby, es un tema importante.


Otra opción, por comentarla, es UnrealEngine, en C++ actualmente. Aunque si la idea es jugar con escenas, me parece un engine demasiado "tedioso" para ello.

En cuanto a aplicaciones empresariales, C# es una buena elección. Tiene formularios sencillos y muchas facilidades.

Como detalle, el problema que tuviste es que "system()" ejecuta el comando como si fuera otro programa. Cuando se termina el system, el directorio vuelve a ser elque era (en tu programa, no cambió realmente)

La clase ofstream escribe la representación, no el binario.

Haz una cosa. Pon al lado de la línea, esta otra:

fichs << fila[i] << endl;
cout << fila[i] << endl;

Y a ver qué muestra por pantalla. es posible que el error venga de antes.

Después del "fichs.open(msg);", prueba a poner:

if(!fichs.is_open()){
    cout << "Error" << endl;
}

¿El fichero se crea? ¿Tiene algún contenido?

El resultado es el que buscas imagino, así que sí.

Oh, el: material = " ";
No puedes asignar una cadena como esa (char*) a un int. Además, un cout d eun int siempre va a escribir un número; no hay ningún número "vacío".
Tendrás que poner 2 cout, uno en el if y otro en el else, por ejemplo.

Y como detalle, cuando tengas dudas así, pon por aquí el error y su línea. El error tal cual te lo pone el compilador.

Para convertir un puntero a un objeto de una clase a otra clase, tienes 3 casts posibles:

• static_cast: En el momento de compilar, comprueba si lo puede convertir. En tu caso, estás convirtiendo un A* a un B*. Como A* no hereda de B*, dará error. (Aunque sea un AB*, es una variable A* lo que estás convirtiendo a B*)
• dynamic_cast: En vez de comprobar a la hora de compilar, lo hace mientras se ejecuta. Este va a comprobar si se puede hacer el cast, y si no se puede, lanzará una excepción (En este caso se puede, y no tendrás problema).
• reinterpret_cast: Este cast no hace comprobaciones. Se limita a tratar la secuencia de bytes del objeto como si de otro objeto se tratase. En este caso, eso no es suficiente, y por eso falla.

Aquí, tu opción es dynamic_cast. Otra opción (bastante mejor a mi parecer), es utilizar un objeto AB*:

#include <iostream>
using namespace std;
 
class A{
public:
    virtual void opA() = 0;
};
 
class B{
public:
    virtual void opB() = 0;
};
 
class AB: public A, public B{
public:
    void opA(){
        cout<<"Operacion A"<<endl;
    }
    void opB(){
        cout<<"Operacion B"<<endl;
    }
};
 
 
int main(){
    AB* ab = new AB();
    A* variableA = ab;
    B* variableB = ab;
 
    variableA->opA();
    variableB->opB();
 
    delete ab;
    return 0;
}

No necesitarás hacer casts (el cast implícito funciona correctamente en este caso), y además tendrás la certeza de que los tipos son siempre válidos.

En tu ejemplo, estás convirtiendo un A* a un B*. Viendo el código, sabemos que eso funciona, pero no es realmente válido, pues esas clases no tienen relación.

Este último método es preferible ante el dynamic_cast porque te dará error en tiempo de compilación (preferible a una excepción), y la transformación es más rápida (dynamic_cast hace comprobaciones que podemos obviar).

Cuidado con reinterpret_cast a la hora de trabajar con clases. Mejor evitarlo, especialmente cuando se utiliza herencia múltiple.
Un caso de uso de reinterpret_cast podría ser:

int n = 456;
char* bytesDeN = reinterpret_cast<char*>(&n);

EDITO: Y sobre el por qué hace lo que dices, pues: reinterpret_cast en ese caso no hará un cast correcto, y el comportamiento será indefinido. Probablemente, como opA es la primera función, B la coja como si fuera opB. En cualquier caso, este comportamiento es indefinido y no es relevante. Simplemente, debe evitarse.

Esta misma utilidad está también en toros lenguajes, como C#.

No es obligatorio usarlo, pero es útil en múltiples casos. Además, permite un código más "legible" (aunque esto sea subjetivo), si bien hace el código un poco "oscuro", pues ese atributo realmente está haciendo"algo" por detrás.

Ejemplo:
¿Qué es más legible?

x.value = x.value + 5

o

x.setValue(x.getValue() + 5)

Tal vez quisieras poner:

void mostrar(){
  int i, material;
  for (i = 0; i<10; i++){ // Condición para romper el bucle: que i no sea menor que 10
      material = tam[i]; // Aquí asignas la variable
      if (material == 0){
          material = " ";
      }
      cout <<"|" <<material <<"|";
  }
  cout <<endl;
}