컴파일 타임에 8 명의 퀸즈 문제 해결 [닫기]

컴파일 타임에 여덟 명의 여왕 퍼즐 을 풀 수 있습니까 ?

적합한 출력 형식을 선택하십시오.

특히 C ++ 템플릿 메타 프로그래밍 솔루션에 관심이 있지만 Haskell의 유형 시스템과 같은 유사한 구문을 가진 언어를 사용할 수 있습니다.

이상적으로 메타 프로그램은 모든 솔루션을 출력합니다. 하드 코딩이 없습니다.

내 메타 프로그램은 모든 92 솔루션을 찾습니다. 오류 메시지로 인쇄됩니다.

error: 'solution' is not a member of 'print<15863724>'

즉, 첫 번째 여왕은 y = 1에, 두 번째 여왕은 y = 5에, 세 번째 여왕은 y = 8에 배치해야합니다.

먼저 유용한 메타 함수들 :

template <typename T>
struct return_
{
    typedef T type;
};

template <bool Condition, typename Then, typename Else>
struct if_then_else;

template <typename Then, typename Else>
struct if_then_else<true, Then, Else> : return_<Then> {};

template <typename Then, typename Else>
struct if_then_else<false, Then, Else> : return_<Else> {};

template <int N>
struct constant
{
    enum { value = N };
};

template <int N>
struct print
{
    // empty body -> member access yields a compiler error involving N
};

그런 다음 두 가지 흥미로운 메타 함수 (단수와 복수에 주목) :

template <int queens, int rows, int sums, int difs, int x, int y>
struct put_queen;

template <int queens, int rows, int sums, int difs, int x>
struct put_queens : constant
     < put_queen<queens, rows, sums, difs, x, 1>::value
     + put_queen<queens, rows, sums, difs, x, 2>::value
     + put_queen<queens, rows, sums, difs, x, 3>::value
     + put_queen<queens, rows, sums, difs, x, 4>::value
     + put_queen<queens, rows, sums, difs, x, 5>::value
     + put_queen<queens, rows, sums, difs, x, 6>::value
     + put_queen<queens, rows, sums, difs, x, 7>::value
     + put_queen<queens, rows, sums, difs, x, 8>::value > {};

template <int queens, int rows, int sums, int difs, int x, int y>
struct put_queen : if_then_else<
    rows & (1 << y) || sums & (1 << (x + y)) || difs & (1 << (8 + x - y)),
    constant<0>,
    put_queens<queens * 10 + y, rows | (1 << y), sums | (1 << (x + y)),
               difs | (1 << (8 + x - y)), x + 1>
>::type {};

변수 queens는 지금까지 보드에 놓인 여왕의 y 좌표를 저장합니다. 다음 3 개의 변수는 이미 여왕이 차지하고있는 행과 대각선을 저장합니다. x그리고 y자명 할 것이다.

if_then_else현재 위치가 차단되었는지 확인 하는 첫 번째 인수 입니다. 이 경우 재귀는 (의의없는) 결과 0을 반환하여 중지됩니다. 그렇지 않으면 퀸이 보드에 배치되고 프로세스는 다음 열로 계속됩니다.

x가 8에 도달하면 해결책을 찾았습니다.

template <int queens, int rows, int sums, int difs>
struct put_queens<queens, rows, sums, difs, 8>
{
    enum { value = print<queens>::solution };
};

이후 print템플릿에는 부재가없는 solution컴파일러 에러를 발생시킨다.

마지막으로 프로세스를 시작하기 value위해 빈 보드 의 구성원을 검사합니다 .

int go = put_queens<0, 0, 0, 0, 0>::value;

전체 프로그램은 ideone 에서 찾을 수 있습니다 .

Haskell 유형 시스템을 사용하는 솔루션을 생각해 냈습니다. value 수준에서 문제 에 대한 기존 솔루션을 조금 Google 검색하고 조금 변경 한 다음 유형 수준으로 올렸습니다. 많은 재창조가 필요했습니다. 또한 많은 GHC 확장을 활성화해야했습니다.

첫째, 정수는 유형 수준에서 허용되지 않기 때문에 이번에는 자연수를 다시 한 번 유형으로 다시 만들어야했습니다.

data Zero -- type that represents zero
data S n  -- type constructor that constructs the successor of another natural number
-- Some numbers shortcuts
type One = S Zero
type Two = S One
type Three = S Two
type Four = S Three
type Five = S Four
type Six = S Five
type Seven = S Six
type Eight = S Seven

내가 적용한 알고리즘은 내추럴에 덧셈과 뺄셈을하므로 이것도 다시 만들어야했습니다. 타입 레벨의 함수는 타입 클래스에 따라 정의됩니다. 이를 위해서는 다중 매개 변수 유형 클래스 및 기능 종속성에 대한 확장이 필요합니다. 타입 클래스는 "값을 반환"할 수 없으므로 PROLOG와 비슷한 방식으로 추가 매개 변수를 사용합니다.

class Add a b r | a b -> r -- last param is the result
instance Add Zero b b                     -- 0 + b = b
instance (Add a b r) => Add (S a) b (S r) -- S(a) + b = S(a + b)

class Sub a b r | a b -> r
instance Sub a Zero a                     -- a - 0 = a
instance (Sub a b r) => Sub (S a) (S b) r -- S(a) - S(b) = a - b

재귀는 클래스 어설 션으로 구현되므로 구문이 약간 뒤로 보입니다.

다음은 부울입니다.

data True  -- type that represents truth
data False -- type that represents falsehood

불평등 비교를 수행하는 함수 :

class NotEq a b r | a b -> r
instance NotEq Zero Zero False                -- 0 /= 0 = False
instance NotEq (S a) Zero True                -- S(a) /= 0 = True
instance NotEq Zero (S a) True                -- 0 /= S(a) = True
instance (NotEq a b r) => NotEq (S a) (S b) r -- S(a) /= S(b) = a /= b

그리고 목록 ...

data Nil
data h ::: t
infixr 0 :::

class Append xs ys r | xs ys -> r
instance Append Nil ys ys                                       -- [] ++ _ = []
instance (Append xs ys rec) => Append (x ::: xs) ys (x ::: rec) -- (x:xs) ++ ys = x:(xs ++ ys)

class Concat xs r | xs -> r
instance Concat Nil Nil                                         -- concat [] = []
instance (Concat xs rec, Append x rec r) => Concat (x ::: xs) r -- concat (x:xs) = x ++ concat xs

class And l r | l -> r
instance And Nil True                    -- and [] = True
instance And (False ::: t) False         -- and (False:_) = False
instance (And t r) => And (True ::: t) r -- and (True:t) = and t

if유형 수준에서도 누락되었습니다 ...

class Cond c t e r | c t e -> r
instance Cond True t e t  -- cond True t _ = t
instance Cond False t e e -- cond False _ e = e

그리고 그로 인해 제가 사용한 모든 지원 기계가 제자리에있었습니다. 문제 자체를 해결할 시간입니다!

기존 보드에 여왕을 추가해도 괜찮은지 테스트하는 기능으로 시작 :

-- Testing if it's safe to add a queen
class Safe x b n r | x b n -> r
instance Safe x Nil n True    -- safe x [] n = True
instance (Safe x y (S n) rec,
          Add c n cpn, Sub c n cmn,
          NotEq x c c1, NotEq x cpn c2, NotEq x cmn c3,
          And (c1 ::: c2 ::: c3 ::: rec ::: Nil) r) => Safe x (c ::: y) n r
    -- safe x (c:y) n = and [ x /= c , x /= c + n , x /= c - n , safe x y (n+1)]

클래스 어설 션을 사용하여 중간 결과를 얻습니다. 반환 값은 실제로 추가 매개 변수이므로 어설 션을 서로 직접 호출 할 수는 없습니다. 다시 한 번 PROLOG를 사용했다면이 스타일이 다소 친숙 할 것입니다.

람다의 필요성을 없애기 위해 몇 가지 변경을 한 후 (구현 가능했지만 다른 날로 떠나기로 결정한) 원래 솔루션은 다음과 같습니다.

queens 0 = [[]]
-- The original used the list monad. I "unrolled" bind into concat & map.
queens n = concat $ map f $ queens (n-1)
g y x = if safe x y 1 then [x:y] else []
f y = concat $ map (g y) [1..8]

map고차 함수입니다. 고차원의 메타 함수를 구현하는 것이 너무 번거로울 것이라고 생각 했기 때문에 더 간단한 해결책을 찾았습니다. 어떤 함수가 매핑 될지 알기 map때문에 각각 에 대한 특수 버전을 구현할 수 있습니다. 고차 함수.

-- Auxiliary meta-functions
class G y x r | y x -> r
instance (Safe x y One s, Cond s ((x ::: y) ::: Nil) Nil r) => G y x r

class MapG y l r | y l -> r
instance MapG y Nil Nil
instance (MapG y xs rec, G y x g) => MapG y (x ::: xs) (g ::: rec)

-- Shortcut for [1..8]
type OneToEight = One ::: Two ::: Three ::: Four ::: Five ::: Six ::: Seven ::: Eight ::: Nil

class F y r | y -> r
instance (MapG y OneToEight m, Concat m r) => F y r -- f y = concat $ map (g y) [1..8]

class MapF l r | l -> r
instance MapF Nil Nil
instance (MapF xs rec, F x f) => MapF (x ::: xs) (f ::: rec)

그리고 마지막 메타 함수를 지금 작성할 수 있습니다 :

class Queens n r | n -> r
instance Queens Zero (Nil ::: Nil)
instance (Queens n rec, MapF rec m, Concat m r) => Queens (S n) r

남은 것은 형식 검사 기계를 동축하여 솔루션을 해결하는 일종의 동인입니다.

-- dummy value of type Eight
eight = undefined :: Eight
-- dummy function that asserts the Queens class
queens :: Queens n r => n -> r
queens = const undefined

이 메타 프로그램은 유형 검사기에서 실행되어야하므로 ghci다음 유형을 요청할 수 있습니다 queens eight.

> :t queens eight

이것은 기본 재귀 제한을 다소 빠르게 초과합니다 (약 20입니다). 이 한계를 증가시키기 위해, 우리는 호출 할 필요가 ghci과 -fcontext-stack=N옵션, N원하는 스택 깊이 (N = 1000 십오 분 충분하지 않습니다). 시간이 오래 걸리기 때문에 아직이 실행을 완료하지는 못했지만을 (를) 실행했습니다 queens four.

결과 유형을 예쁘게 인쇄하기위한 일부 기계 장치 가 있는 전체 프로그램 이 queens two있습니다.

전처리기를 통한 C

ANSI위원회는 C 전처리기를 Turing-complete 상태로 확장하지 않기 위해 신중한 선택을했다고 생각합니다. 어쨌든 여덟 명의 여왕 문제를 해결하기에 충분히 강력하지는 않습니다. 일반적인 방식은 아닙니다.

그러나 루프 카운터를 하드 코딩하려는 경우 가능합니다. 물론 반복하는 실제 방법은 없지만을 통해 자체 포함을 사용 #include __FILE__하여 제한된 종류의 재귀를 얻을 수 있습니다.

#ifdef i
# if (r_(i) & 1 << j_(i)) == 0 && (p_(i) & 1 << i + j_(i)) == 0 \
                               && (n_(i) & 1 << 7 + i - j_(i)) == 0
#  if i == 0
#   undef i
#   define i 1
#   undef r1
#   undef p1
#   undef n1
#   define r1 (r0 | (1 << j0))
#   define p1 (p0 | (1 << j0))
#   define n1 (n0 | (1 << 7 - j0))
#   undef j1
#   define j1 0
#   include __FILE__
#   undef j1
#   define j1 1
#   include __FILE__
#   undef j1
#   define j1 2
#   include __FILE__
#   undef j1
#   define j1 3
#   include __FILE__
#   undef j1
#   define j1 4
#   include __FILE__
#   undef j1
#   define j1 5
#   include __FILE__
#   undef j1
#   define j1 6
#   include __FILE__
#   undef j1
#   define j1 7
#   include __FILE__
#   undef i
#   define i 0
#  elif i == 1
#   undef i
#   define i 2
#   undef r2
#   undef p2
#   undef n2
#   define r2 (r1 | (1 << j1))
#   define p2 (p1 | (1 << 1 + j1))
#   define n2 (n1 | (1 << 8 - j1))
#   undef j2
#   define j2 0
#   include __FILE__
#   undef j2
#   define j2 1
#   include __FILE__
#   undef j2
#   define j2 2
#   include __FILE__
#   undef j2
#   define j2 3
#   include __FILE__
#   undef j2
#   define j2 4
#   include __FILE__
#   undef j2
#   define j2 5
#   include __FILE__
#   undef j2
#   define j2 6
#   include __FILE__
#   undef j2
#   define j2 7
#   include __FILE__
#   undef i
#   define i 1
#  elif i == 2
#   undef i
#   define i 3
#   undef r3
#   undef p3
#   undef n3
#   define r3 (r2 | (1 << j2))
#   define p3 (p2 | (1 << 2 + j2))
#   define n3 (n2 | (1 << 9 - j2))
#   undef j3
#   define j3 0
#   include __FILE__
#   undef j3
#   define j3 1
#   include __FILE__
#   undef j3
#   define j3 2
#   include __FILE__
#   undef j3
#   define j3 3
#   include __FILE__
#   undef j3
#   define j3 4
#   include __FILE__
#   undef j3
#   define j3 5
#   include __FILE__
#   undef j3
#   define j3 6
#   include __FILE__
#   undef j3
#   define j3 7
#   include __FILE__
#   undef i
#   define i 2
#  elif i == 3
#   undef i
#   define i 4
#   undef r4
#   undef p4
#   undef n4
#   define r4 (r3 | (1 << j3))
#   define p4 (p3 | (1 << 3 + j3))
#   define n4 (n3 | (1 << 10 - j3))
#   undef j4
#   define j4 0
#   include __FILE__
#   undef j4
#   define j4 1
#   include __FILE__
#   undef j4
#   define j4 2
#   include __FILE__
#   undef j4
#   define j4 3
#   include __FILE__
#   undef j4
#   define j4 4
#   include __FILE__
#   undef j4
#   define j4 5
#   include __FILE__
#   undef j4
#   define j4 6
#   include __FILE__
#   undef j4
#   define j4 7
#   include __FILE__
#   undef i
#   define i 3
#  elif i == 4
#   undef i
#   define i 5
#   undef r5
#   undef p5
#   undef n5
#   define r5 (r4 | (1 << j4))
#   define p5 (p4 | (1 << 4 + j4))
#   define n5 (n4 | (1 << 11 - j4))
#   undef j5
#   define j5 0
#   include __FILE__
#   undef j5
#   define j5 1
#   include __FILE__
#   undef j5
#   define j5 2
#   include __FILE__
#   undef j5
#   define j5 3
#   include __FILE__
#   undef j5
#   define j5 4
#   include __FILE__
#   undef j5
#   define j5 5
#   include __FILE__
#   undef j5
#   define j5 6
#   include __FILE__
#   undef j5
#   define j5 7
#   include __FILE__
#   undef i
#   define i 4
#  elif i == 5
#   undef i
#   define i 6
#   undef r6
#   undef p6
#   undef n6
#   define r6 (r5 | (1 << j5))
#   define p6 (p5 | (1 << 5 + j5))
#   define n6 (n5 | (1 << 12 - j5))
#   undef j6
#   define j6 0
#   include __FILE__
#   undef j6
#   define j6 1
#   include __FILE__
#   undef j6
#   define j6 2
#   include __FILE__
#   undef j6
#   define j6 3
#   include __FILE__
#   undef j6
#   define j6 4
#   include __FILE__
#   undef j6
#   define j6 5
#   include __FILE__
#   undef j6
#   define j6 6
#   include __FILE__
#   undef j6
#   define j6 7
#   include __FILE__
#   undef i
#   define i 5
#  elif i == 6
#   undef i
#   define i 7
#   undef r7
#   undef p7
#   undef n7
#   define r7 (r6 | (1 << j6))
#   define p7 (p6 | (1 << 6 + j6))
#   define n7 (n6 | (1 << 13 - j6))
#   undef j7
#   define j7 0
#   include __FILE__
#   undef j7
#   define j7 1
#   include __FILE__
#   undef j7
#   define j7 2
#   include __FILE__
#   undef j7
#   define j7 3
#   include __FILE__
#   undef j7
#   define j7 4
#   include __FILE__
#   undef j7
#   define j7 5
#   include __FILE__
#   undef j7
#   define j7 6
#   include __FILE__
#   undef j7
#   define j7 7
#   include __FILE__
#   undef i
#   define i 6
#  elif i == 7
    printf("(1 %d) (2 %d) (3 %d) (4 %d) (5 %d) (6 %d) (7 %d) (8 %d)\n",
           j0 + 1, j1 + 1, j2 + 1, j3 + 1, j4 + 1, j5 + 1, j6 + 1, j7 + 1);
#  endif
# endif
#else
#include <stdio.h>
#define _cat(a, b) a ## b
#define j_(i) _cat(j, i)
#define n_(i) _cat(n, i)
#define p_(i) _cat(p, i)
#define r_(i) _cat(r, i)
int main(void)
{
# define i 0
# define j0 0
# include __FILE__
# undef j0
# define j0 1
# include __FILE__
# undef j0
# define j0 2
# include __FILE__
# undef j0
# define j0 3
# include __FILE__
# undef j0
# define j0 4
# include __FILE__
# undef j0
# define j0 5
# include __FILE__
# undef j0
# define j0 6
# include __FILE__
# undef j0
# define j0 7
# include __FILE__
# undef j0
    return 0;
}
#endif

끔찍한 반복적 인 내용에도 불구하고, 그것이 8 개의 여왕 문제를 알고리즘 적으로 해결하고 있다는 것을 확신시켜 드리겠습니다. 불행히도 전처리기로 할 수 없었던 한 가지는 일반적인 푸시 다운 스택 데이터 구조를 구현하는 것입니다. 결론은 i설정 할 다른 값을 선택하는 데 사용 된 곳 의 값을 하드 코딩해야 한다는 것입니다. (일반적으로 수행 할 수있는 값 검색과는 반대로 #if파일의 맨 위에있는 여왕이 현재 위치에 추가 될 수 있는지 여부를 결정하는 이유는 8 번 반복 할 필요가 없습니다.)

프리 프로세서 코드 내에서, i그리고 j현재 위치를 표시는 동안, 고려되고 r, p및 n킵 트랙 어느 계급과 대각선 현재 위치에 사용할 수 없습니다. 그러나 i현재 재귀 수준을 표시하는 카운터로도 두 배가되므로 실제로 다른 모든 값은 실제로 i를 일종의 첨자로 사용하므로 재귀에서 다시 시작할 때 해당 값이 유지됩니다. 또한 전 처리기 기호 값을 완전히 바꾸지 않고 수정하기가 매우 어려워졌습니다.

컴파일 된 프로그램은 92 개의 솔루션을 모두 인쇄합니다. 솔루션은 실행 파일에 직접 포함됩니다. 전 처리기 출력은 다음과 같습니다.

/* ... #included content from <stdio.h> ... */
int main(void)
{
    printf("(1 %d) (2 %d) (3 %d) (4 %d) (5 %d) (6 %d) (7 %d) (8 %d)\n",
           0 + 1, 4 + 1, 7 + 1, 5 + 1, 2 + 1, 6 + 1, 1 + 1, 3 + 1);
    printf("(1 %d) (2 %d) (3 %d) (4 %d) (5 %d) (6 %d) (7 %d) (8 %d)\n",
           0 + 1, 5 + 1, 7 + 1, 2 + 1, 6 + 1, 3 + 1, 1 + 1, 4 + 1);
    printf("(1 %d) (2 %d) (3 %d) (4 %d) (5 %d) (6 %d) (7 %d) (8 %d)\n",
           0 + 1, 6 + 1, 3 + 1, 5 + 1, 7 + 1, 1 + 1, 4 + 1, 2 + 1);
    /* ... 88 more solutions ... */
    printf("(1 %d) (2 %d) (3 %d) (4 %d) (5 %d) (6 %d) (7 %d) (8 %d)\n",
           7 + 1, 3 + 1, 0 + 1, 2 + 1, 5 + 1, 1 + 1, 6 + 1, 4 + 1);
    return 0;
}

분명히해서는 안되지만 할 수 있습니다.

템플릿이없는 C ++ 11 솔루션은 다음과 같습니다.

constexpr int trypos(
    int work, int col, int row, int rows, int diags1, int diags2,
    int rowbit, int diag1bit, int diag2bit);

constexpr int place(
    int result, int work, int col, int row, int rows, int diags1, int diags2)
{
    return result != 0 ? result
        : col == 8 ? work
        : row == 8 ? 0
        : trypos(work, col, row, rows, diags1, diags2,
                 1 << row, 1 << (7 + col - row), 1 << (14 - col - row));
}

constexpr int trypos(
    int work, int col, int row, int rows, int diags1, int diags2,
    int rowbit, int diag1bit, int diag2bit)
{
    return !(rows & rowbit) && !(diags1 & diag1bit) && !(diags2 & diag2bit)
        ? place(
            place(0, work*10 + 8-row, col + 1, 0,
                  rows | rowbit, diags1 | diag1bit, diags2 | diag2bit),
            work, col, row + 1, rows, diags1, diags2)
        : place(0, work, col, row + 1, rows, diags1, diags2);
}

int places = place(0, 0, 0, 0, 0, 0, 0);

솔루션은 FredOverflow의 답변과 같이 십진수로 인코딩됩니다. GCC 4.7.1은 다음을 사용하여 위 파일을 다음 어셈블리 소스로 컴파일합니다 g++ -S -std=c++11 8q.cpp.

    .file   "8q.cpp"
    .globl  places
    .data
    .align 4
    .type   places, @object
    .size   places, 4
places:
    .long   84136275
    .ident  "GCC: (GNU) 4.7.1"
    .section    .note.GNU-stack,"",@progbits

심볼의 값 places은 84136275, 즉 첫 번째 여왕은 a8, 두 번째는 b4 등입니다.

하나의 템플리트 클래스 만있는 c ++ 템플리트가 정의됩니다.

template <int N, int mask, int mask2, int mask3, int remainDigit, bool fail>
struct EQ;

template <int N, int mask, int mask2, int mask3>
struct EQ<N, mask, mask2, mask3, 0, false> {
    enum _ { Output = (char [N])1 };
};

template <int N, int mask, int mask2, int mask3, int i>
struct EQ<N, mask, mask2, mask3, i, true> { };

template <int N, int mask, int mask2, int mask3, int i>
struct EQ<N, mask, mask2, mask3, i, false> {
    enum _ { _ = 
             sizeof(EQ<N*10+1, mask|(1<<1), mask2|(1<<(1+i)), mask3|(1<<(1+8-i)), i-1, 
               (bool)(mask&(1<<1)) || (bool)(mask2&(1<<(1+i))) || (bool)(mask3&(1<<(1+8-i)))>) +
             sizeof(EQ<N*10+2, mask|(1<<2), mask2|(1<<(2+i)), mask3|(1<<(2+8-i)), i-1, 
               (bool)(mask&(1<<2)) || (bool)(mask2&(1<<(2+i))) || (bool)(mask3&(1<<(2+8-i)))>) +
             sizeof(EQ<N*10+3, mask|(1<<3), mask2|(1<<(3+i)), mask3|(1<<(3+8-i)), i-1, 
               (bool)(mask&(1<<3)) || (bool)(mask2&(1<<(3+i))) || (bool)(mask3&(1<<(3+8-i)))>) +
             sizeof(EQ<N*10+4, mask|(1<<4), mask2|(1<<(4+i)), mask3|(1<<(4+8-i)), i-1, 
               (bool)(mask&(1<<4)) || (bool)(mask2&(1<<(4+i))) || (bool)(mask3&(1<<(4+8-i)))>) +
             sizeof(EQ<N*10+5, mask|(1<<5), mask2|(1<<(5+i)), mask3|(1<<(5+8-i)), i-1, 
               (bool)(mask&(1<<5)) || (bool)(mask2&(1<<(5+i))) || (bool)(mask3&(1<<(5+8-i)))>) +
             sizeof(EQ<N*10+6, mask|(1<<6), mask2|(1<<(6+i)), mask3|(1<<(6+8-i)), i-1, 
               (bool)(mask&(1<<6)) || (bool)(mask2&(1<<(6+i))) || (bool)(mask3&(1<<(6+8-i)))>) +
             sizeof(EQ<N*10+7, mask|(1<<7), mask2|(1<<(7+i)), mask3|(1<<(7+8-i)), i-1, 
               (bool)(mask&(1<<7)) || (bool)(mask2&(1<<(7+i))) || (bool)(mask3&(1<<(7+8-i)))>) +
             sizeof(EQ<N*10+8, mask|(1<<8), mask2|(1<<(8+i)), mask3|(1<<(8+8-i)), i-1, 
               (bool)(mask&(1<<8)) || (bool)(mask2&(1<<(8+i))) || (bool)(mask3&(1<<(8+8-i)))>)};
};
int main(int argc, _TCHAR* argv[])
{
    // output all solutions to eight queens problems as error messages
    sizeof(EQ<0, 0, 0, 0, 8, false>);
    return 0;
}

오류 메시지는 다음과 같습니다.

오류 C2440 : 'type cast': 'int'에서 'char [15863724]'로 변환 할 수 없습니다