Cuando los strings los defines como char [] esos strings allí guardados, no se comparan con ==
Para ese caso, usa strcmp o strncmp o crea una función que recorra los arreglos y los compare.

Sugiero partir de cero que recortar este programa. No parece ser un ejemplo de buenas practicas.

Por otro lado, si sabes de ciclos, for y printf, sugiero que hagas el reemplazo que propones tu mismo.

Super bueno.

Le falta la aritmetica para los indices de la matriz (y llenarla).
Sin embargo, agregarla diluye la magia de la simplicidad inicial.

En la funcion busquedaPos tienes un while, con una condicion.
Cuando esa condicion se hace falsa?

Yo creo que nunca, porque parece que no estas modificando las variables que controlan el ciclo.

Solo por jugar, para poder repetir los valores antes de llegar al final del arreglo cartas, se puede hacer un truco: usar la matriz final como memoria adicional y aplicar la misma idea anterior, e.g.: http://goo.gl/mOF4jJ

Aun no es como lo descrito, pero la idea se puede aplicar de multiples formas para evitar o forzar repeticiones, sin requerir de estructuras de datos adicionales o contar, la solucion funciona por construccion, como se demuestra en el codigo del link, el que copio aqui:

#include <stdio.h>
#include <stdlib.h> 
#include <time.h> 
 
char a[4][4]; 
char cartas[] = {'#','%','@','*','!','<','?', '+'};
int total=sizeof(cartas);
 
int main()
{
    for(int i = 0; i < total*2; i++) {
        a[i/4][i%4] = cartas[i%8];
    }
 
    srand(time(0));
    for (int mover_a = total*2-1; mover_a >=0; mover_a--) {
        int hacia = mover_a;
        int desde = rand() % (hacia + 1);
 
        char temp = a[hacia/4][hacia%4];
        a[hacia/4][hacia%4] = a[desde/4][desde%4];
        a[desde/4][desde%4] = temp;
 
        printf("\t%c ",a[hacia/4][hacia%4]);
        if(mover_a%4 == 0) printf("\n");
 
   }
   printf("\n\n");
}

Verlo ejecutando aqui; http://goo.gl/mOF4jJ

Es completamente posible que aparezca en la salida un patron como el del enunciado.
Hay que cambiar el arreglo de cartas para que incluya el "?" y sacar la "x" que puse yo sin fijarme.

O(1) espacio
O(n) operaciones, n el tamaño del arreglo de cartas, la mitad de la matriz

Verlo ejecutándose aquí: http://goo.gl/KLHE8S

#include <stdio.h>
#include <stdlib.h> 
#include <time.h> 
 
char a[4][4]; 
char cartas[] = {'#','%','@','*','!','<','x', '+'};
int total=sizeof(cartas);
 
int main()
{
    int mover_a = total*2-1;
    srand(time(0));
    for (int i=0; i < 4; i++) {
        for (int j=0; j < 4; j++) {
            int hacia = mover_a % total;
            int desde = rand() % (hacia + 1);
 
            a[i][j] = cartas[desde];
            cartas[desde] = cartas[hacia];
            cartas[hacia] = a[i][j];
 
            printf("\t%c ",a[i][j]);
 
            mover_a--;
        }
      printf("\n\n");
    }
}
 

Al arreglo cartas le falta 1 elemento, la matriz de 4x4 = 16 caracteres, y cartas tiene tamano 7.

Una idea alternativa es que modifiques el arreglo de cartas, eligiendo aleatoriamente desde el, y llevando al final o al inicio la carta elegida, y recorrerlo 2 veces. Con eso, no requieres memoria adicional, ninguna estructura de datos extra, y llevar donde vas en 1 indice adicional.

Una solucion alternativa a usar macros, pero que tampoco es exactamente lo que buscas, es usar functors. Se trata de clases o structs que tienen un metodo operator() y que puede ser redefinido en otras clases. Es eso lo que hice en el codigo que incluyo aqui:

#include <functional>
#include <iostream>
 
using namespace std;
 
// tu clase Num, con metodos adicionales para hacer mas corto el resto
class Num 
{	
public:
    double a, b;
    Num(double x, double y) : a(x), b(y) {}
    void show() { cout << a << ":" << b << endl; }
};
 
// la definicion del functor
struct Operador : public binary_function<Num,Num,Num> {
    virtual Num operator()(Num&n1, Num& n2) = 0;
};
 
// los operadores
struct Sumador : public Operador {
  Num operator() (Num& n1, Num& n2) {return Num(n1.a+n2.a,n1.b+n2.b);}
} sumador;
 
struct Multiplicador : public Operador {
  Num operator() (Num& n1, Num& n2) {return Num(n1.a*n2.a,n1.b*n2.b);}
} multiplicador;
 
// definir otros, si se quiere ...
 
// una funcion que aplica los operadores
Num apply_op(Num n1, Num n2, Operador& op) {
  return op(n1, n2);
}
 
int main() {
    Num num1(1,2), num2(3,4);
 
    apply_op(num1, num2, sumador).show();
    apply_op(num1, num2, multiplicador).show();
 
    // en vez de hacer .show(), como arriba, se puede asignar el resultado, si se quiere
    Num resultado = apply_op( num1, num2, sumador );
    resultado.show();
 
    return 0;
}

La definición es antes que el uso.
Define tlibro antes que _nodo
Luego usa el * entre el tipo y el nombre del campo.