que tal si cierras la llave despues de return 0; y antes de int dados() ?

No dije que no se pueden usar parámetros.
Dije que no se pueden usar variables como parámetros de la especialización.

Vale decir, no puedes usar

mifunc<i>()

Solo puedes usar constantes, como en el ejemplo que mande

Yo no tengo a la vista el xorstr que mencionas.

Se me ocurre una manera de hacerlo, pero no es tan directo como llegar e invocar una funcion. En C++, los templates generan codigo y cada especializacion es codigo distinto.
De esta manera, basta que uses una especializacion cada vez que invocas la funcion.

Ejemplo:

#include <iostream>
using namespace std;
 
template <int N> void myfunc1() {  cout << N << endl; }
 
template <int N> void myfunc2() {  cout << "No me importa el valor de N" << endl;  }
 
int main()
{
    // Invocar una funcion a la que le interesa usar el valor explicito
    // todas las funciones son distintas
    myfunc1<1>();
    myfunc1<456>();
 
    // Invocar una funcion en que el parametro del template se ignora
    myfunc2<1234>();
 
    return 0;
}
 

Puedes ver este codigo ejecutandose en este link:  http://goo.gl/x3aJ9X

No puedes usar variables como parametro de la especializacion. Solo constantes explicitas.

Creo que el problema que tienes esta en los tipos de datos que usas.

En C hay clausura de tipos.
Si operas 2 tipos int, el resultado es int.

por ejemplo, 5 /3 es 1, no es 1.66666
otro ejemplo  2/4 es 0, no es 0.5

puedes forzar que se operen numeros float a pesar de tener int haciendo un cast hacia ese tipo asi:

(float) 2 / (float) 4

Existe otra regla respecto a operar tipos distinto, no es exactamente asi, pero para entenderlo, el tipo mas chico se convierte en el tipo mas grande

float operado con int, el compilador hace el cast por ti, entonces

(float) 2 / (float) 4 es igual a  (float) 2 / 4 y es igual a 2 / (float) 4.

reemplaza 2 y 4 por variables de tipo int y tendras algo mas generico.

malloc(sizeof(strlen(x)))

No tiene sentido.

Usa

malloc(1+strlen(x))

Que pide memoria por el tamaño en bytes del string x


Otra cosa que note, pero que no es un problema, realmente, aunque es bueno saberlo es que sizeof(char) es siempre 1, no es necesario incluirlo.

La compilacion no es barata.
Toma tiempo y recursos,
Si la clase tiene varios campos, el compilador tiene q chequear todo otra vez.
Más económico en tiempo y recursos, si solo usas un puntero a la clase, declararlo así

Una clase se puede declarar o definir o ambas.
Si solo pones el nombre sin especificar como esta definida, se trata de la declaracion.
Solo requieres un nombre, en ese momento. En alguna parte de tu programa tiene que estar esa variable definida, sino el programa no va a linkear.

Solo es posible definir punteros a los tipos declarados. Esto es posible, pues al compilador solo le interesa conocer el tamano de los datos y el tamano de los punteros no depende de los datos apuntados, es constante.

Si modificaras el programa y removieras el * y en vez de puntero fuera un campo de ese tipo, el compilador no va a aceptar la declaracion pues no tiene manera de calcular el tamano.

Las direcciones de memoria son del mismo tamano, no importa a que dato apunten.
Lo malo es que los datos si tienen tipo.
3 soluciones posibles.

Solucion 1:
Haz 2 funciones, una que lee un int, otra que lee float y RETORNA el valor leido

luego en tu programa haces

mivariable = funcionqueleeint();

y la funcionqueleeint() hace de todo, lee, chequea, itera, y devuelve el dato listo.
Haz lo mismo con otra funcion que lee float.

Solucion 2a:
Te gusta, quieres aprender o necesitas usar punteros.
Define 2 funciones, 1 que lee floats, otra que lee int. Hace lo mismo que lo anterior, pero en vez de retornar los valores, los asigna a la variable que se pasa como parametro.

Invocalas de manera separada de acuerdo al tipo de dato que quieres leer.

Quieres leer un int ?

void mifuncionlectoraparaint( int * punteroaint)  {
  printf("Ingrese int" );
  scanf("%d", punteroaint);
  int valoringresado = *punteroaint;
 
  // mas logica usando el valor ingresado, que se obtiene usando valoringresado
}

se usa desde otro lados, al estilo scanf

...
 mifuncionlectoraparaint( & mivariableint )

Lo mismo con float

Solucion 2b.
Alternativa: Usas una variable local a la funcion para leer y solo asignas al final:

void mifuncionlectoraparaint( int * punteroaint)  {
  int variablelocal;
  printf("Ingrese int" );
  scanf("%d", &variablelocal);
 
  // agregar logica aqui que use la variable local
 
...
 
  // y al final
  *punteroaint = variablelocal;
}

Solucion 3a:
1 sola funcion que lee ints y floats

void mifuncionlectoraparatodos( void * punteroadato, int esEntero)  {
  if( esEntero == 1 ) {
     printf("Ingrese int" );
     scanf("%d", (int *) punteroadato);
     int valoringresado =*(int *) punteroadato;
     // logica especifica para int, usando valoringresado
  } else {
     printf("Ingrese float" );
     scanf("%f", (float *) punteroadato);
     float valoringresado = *(float *) punteroadato;
     // logica especifica para float, usando valoringresado
  }
}

Se invoca de todos lados indicando si lo que se quiere leer es int o no, mas la direccion de memoria

Solucion 3b.
Lo mismo anterior, pero usar una variable local, y solo asignar al final, parecido a la solucion 2b.

que tipo de dato es precUni ?
que tipo de dato es el primer parametro de tu funcion restriccion?
Calzan?

En C existe el paso por valor, en C++ existe el paso por referencia. Por lo que veo estas usando paso por valor, y luego en tu funcion restriccion usas la direccion de memoria de la copia que esta siendo creada, no la direccion de memoria de la variable original, no hay manera que la variable original cambie:

- haz que los tipo de los datos que pasas calcen
- pasa direcciones de memoria a las funciones si quieres que las funciones cambien los datos, al estilo de la funcion scanf.

Creo que el problema esta en lo que no se ve.

Como estas definiendo str_global?

No lo muestras, muestras que estas copiando en esa variable, pero no aparece definida.
Ahi debe estar el problema.