Por la forma en como se accede a la jerarquía de clases: usando un punto entre elementos en vez de los dos puntos.

Esa respuesta es para C# en .NET

Si es muy larga usa la página pastebin.com y cuelgas la dirección aquí.

Fragmento de código que hice como respuesta a un juego de mastermind para responder en otro post. Ofrece la funcionalidad de que mira que la entrada de teclado sea efectivamente un número del mismo número de dígitos que la incógnita a buscar, en este programa es un número de 4 dígitos.

#include <stdio.h>
#include <ctype.h>
#include <string.h>
 
#define clrfstr(X) { \
    if(!strchr((X), '\n')) \
        while(getchar() != '\n'); \
}
 
int validar(char cadena[], size_t sizestr, size_t nelements) {
    int i;
    int ok = 1;
 
    for(i = 0; i<4 && ok; i++)
        ok = isdigit(cadena[i]);
    if(cadena[nelements] != '\n')
        ok = 0;
 
    return ok;
}
 
int main() {
    const char incognita[] = "1234";
    const int intentos = 10;
    char entrada[sizeof incognita + 1];
    int i;
    int ganador = 0;
 
    for(i = 0; i < intentos && !ganador; ++i) {
        printf("%03i > ", i+1);
        fgets(entrada, sizeof entrada, stdin);
        clrfstr(entrada);
        if(!validar(entrada, sizeof entrada, strlen(incognita)))
            printf("<<< ERROR >>>\n\n");
        else
            ganador = 1;
    }
 
    return 0;
}
 

Prueba a introducir valores de diferentes cantidades de dígitos, p.ej: 1234, 12, 123456...
ahora borra, o comenta, la línea 6 y vuelve a probar otra vez. Se ve claramente la diferencia del comportamiento del programa.

Intentando responder a un post y, como siempre pruebo el código de mi respuesta antes, necesitaba de una forma genérica una instrucción para limpiar el buffer de entrada stdin después de adquirir una cadena de entrada mediante fgets.

fgets, según el largo de la cadena introduce saca de stdin el carácter '\n' o no y si se usa while (getchar() != '\n'); sin que haya un carácter de nueva línea en el buffer el programa se detiene y espera a que el usuario introduzca algo. Y eso no queda bien.. Por otra parte controlar a mano si hay o no un carácter de nueva línea es engorroso y ensucia el código.

Llegué a la siguiente solución. Necesita de la librería string.h.

#include <string.h>
 
#define clrfstr(X) { \
    if(!strchr((X), '\n')) \
        while(getchar() != '\n'); \
}

Esto vacía, o no, stdin dependiendo de si ha la cadena ingresada contiene, o no, el carácter de nueva línea.

El código se debe incluir justo después de fgets o de la función que se haya usado para adquirir la cadena. X es el argumento que representa a la variable cadena adquirida.

Ahora no tengo tiempo de probar nada.

Para conseguir el módulo de doubles usa fmod.

---

Lo he probado y deberás buscar otra solución para conseguir el factorial de 100.
tu programa dice
100! = 93326215443944102188325606108575267240944254854960571509166910400407995064242937148632694030450512898042989296944474898258737204311236641477561877016501813248

python3 dice
100! = 933262154439441526816992388562667004907159682643816214685929638952175999932299156089414639761565182862536979208272237582511852109168640000000000000000000000

Replanteé la fórmula en base a la física básica de instituto. Hace tanto que no toco todo esto que no puedo asegurar que esté bien, por eso te pedía los resultados, si los tenías.

Partiendo de la formula de la aceleración: a = (vf - vo) / (tf - to)
y de la fórmula del espacio recorrido por una velocidad constante: e = v * t

donde
a : aceleración en m/s^2
v : velocidad en m/s
t : tiempo en s

Siendo:
vx : velocidad horizontal
vy : velocidad vertical
vo : velocidad inical
A : ángulo de disparo
ym : altura del cañón respeto al suelo
g : aceleración de la gravedad = 9.8m/s^2

vx = vo * cos(A)
vy = vo * sin(A)

1. ALTURA MÁXIMA
g = (vf - vo) / (tf - to) = -vo / tf

La aceleración es negativa puesto que va frenando. Consideramos pues -g
-g = -vo / tf
tf = -vo / -g = vo / g   =>   t1 = vy / g

e = v * t    =>    h = vy * t1      ( h es la altura máxima que adquiere el proyectil respecto al cañón )
h = vy * (vy / g) = vy^2 / g

ht = ym + h    (ht es la altura máxima con respecto al suelo)

2. TIEMPO DE CAÍDA
g = (vf - vo) / (tf - to)
v = e / t

g = (ht / tp) - 0 / 1 - 0 = ht / tp    ( tp es el tiempo desde la máxima altura hasta que toca suelo )
tp = ht / g

3. ESPACIO HORIZONTAL RECORRIDO
t = t1 + tp    ( t es el tiempo de vuelo del proyectil: el tiempo de subida más el tiempo de bajada )
e = vx * t

4. SUSTITUYENDO
e = vx * t
e = vx * (t1 + tp)
e = vx * (vy/g + ht/g) = vx * [(vy + ht) / g] = vx * (vy + ht) / g
e = vx * (vy + ym + h) / g
e = vx * (vy + ym + vy^2 / g) / g

De esta forma el programa resulta en lo siguiente:

#include <stdio.h>
#include <math.h>
 
#define M_PI 3.14159265359
#define DEG2RAD(X) (X)*M_PI/180
 
int main() {
    const double g = 9.8;
    const double Vo = 105;
    const double Ym = 15;
    double Vx;
    double Vy;
    double angulo;
    double angulof;
    double d;
 
    for(angulo = 20; angulo <= 80; angulo += 20) {
        angulof = DEG2RAD(angulo);
        Vx = Vo * cos(angulof);
        Vy = Vo * sin(angulof);
        d = Vx * (Vy + Ym + Vy*Vy/g) / g;
        printf("d(%02.0fº) = %f\n", angulo, d);
    }
    return 0;
}

Mira si el número de asteriscos en 4. Si es así para el bucle. Puedes ponerlo en la condición del while: intentos<100 && asteriscos!=4

Estoy oxidado en matemáticas.

Tengo los siguientes resultados:
d(20º) = 1837.556662
d(40º) = 4492.157928
d(60º) = 5087.585718
d(80º) = 2250.260680

¿Tienes los resultados de la ecuación para compararlos?

Bueno, vamos con unos pocos fallos, los más fáciles:

Controla las asignaciones porqué lo que haces es mirar igualdad:
donde escribes j==4 e intentos==100
debe haber j=4 e intentos=100

Tienes un fallo en scanf: el nombre de un array ya es un puntero.
donde escribes scanf("%s", &resp)
debes haber scanf("%s", resp)

Para contar el número de asteriscos, barras verticales y barras bajas en cada iteración estos deben empezar a contar a partir de 0. Así después de do{ debe haber
asteriscos=0, barras=0, bajas=0;

Para el problema de lógica: sea cual sea lo que ha ocurrido acabas haciendo que j=4 y por tanto se detiene ese bucle y por tanto siempre comparas cad==resp[0]. Hay que reescribir eso totalmente.