Jak předat odkaz pole jako parametr ze sestavy k c funkce ++

hlasů
0

Mám dva samostatné soubory ve dvou výtvarných projektech Studio 2012. Jedním z nich je MASM a druhý je C ++. Program MASM má volání funkce DisplayBoard v programu C ++ a je třeba předat odkaz na pole je zobrazování. Nemůžu přijít na to, co přesně je potřeba udělat, aby to fungovalo. Program byl vytvořen v celém rozsahu jako program C ++ a funguje tak, jak by měla, ale my jsme měli dělat většinu kódování v MASM a mají minimální C ++ funkce, takže se snažíme dostat tyto dva soubory mluví, ale mají problémy , Zde jsou kostra kódy pro mé MASM a C ++ soubory. Nejsem si jistý, jestli C ++ soubor musí hlavní, ale to sestavit, aniž by jeden. Také dělá board pole musí být deklarována v souboru C ++, pokud je předán jako parametr? Myslím, že to tak není, ale nejsem si jistý. Já nevím, jestli je parametr pole odkazuje správně v C ++ souboru, nebo ne.

SESTAVA CODE:

TITLE HexAssemblyTest    (HexAssemblyTest.asm)
    .586
    .model flat,C

includelib kernel32.lib
includelib Irvine32.lib

ShowBoard PROTO near C, hexBoard:SDWORD

.data

board SDWORD 121 DUP (0)        ;array to hold the hex board


.code

main PROC 

    INVOKE ShowBoard, ADDR board    ;display board

Retn
main ENDP

END main

Kódu jazyka C ++:

#include stdafx.h
#include<iostream>
#include<iomanip>
#include<Windows.h>
#include<stack>

using namespace std;

extern C void showBoard(int hex_array[]);



//Class DFS definition
class DFSAlgorithm{

public:
int board[121]; //board array


//function to display the board 
    void showBoard(int hex_array[]){

    //code here...

    }
//other functions...removed
    }

};//end DFSAlgorithm class

To je chyba dostaneme:

------ Build začal: Project: HexAssembly Konfigurace: Ladění Win32 ------ 1> Montáž HexAssemblyTest.asm ... 1> HexAssemblyTest.obj: Chyba LNK2019: nevyřešený externí symbol _ShowBoard uváděný ve funkci _main 1 > C: \ Irvine \ Příklady \ assembly Hex programovací \ Debug \ HexAssembly.exe: Závažná chyba LNK1120: 1 nevyřešený externích ========== Kulturista: 0 uspěl, 1 selhala, 0 up-to-date, 0 přeskočí ==========

Myslím, že to mám nyní pracuje správně ... Upravil jsem DFSAlgorithm.cpp a DFSAlgorithm.h, sestavil soubor C ++ a přidal soubor DFSAlsogrithm.obj do projektu, který má soubor sestavy. Oni jsou nyní spojovat, ale jsem stále za „deque iterátor není dereferenceable“ chybová zpráva nyní, kdy C ++ DFS vyhledávání běží. Fungovalo to v pořádku, když se celý program byl v jazyce C ++, takže si nejsem jistý, co musím změnit, aby to fungovalo správně nyní, že pole je získáván ze souboru sestavy. Při procházení s mým debugger, vidím, že je generování sousedů pole, ale nemyslím si, že pole je ve skutečnosti získáván ...

TITLE HexAssemblyTest    (HexAssemblyTest.asm)

INCLUDE Irvine32.inc

printSomething PROTO C ;displays GoobersX
DFS PROTO C, color:BYTE, bptr:PTR DWORD, index:SDWORD

PDWORD TYPEDEF PTR DWORD

.data

bptr PDWORD board   
board SDWORD 121 DUP (0)        ;array to hold the hex board
arrayIndex SDWORD 0         ;variable to hold arrayIndex  


.code

main PROC 

INVOKE printSomething   ;tests if MASM and C++ are talking

Start:          
    CALL PlaceRed       ;prompt user to place a red stone
    CALL clrscr
    CALL crlf
    CALL ShowBoard      ;redraw the board

    ;check if there is a valid path using C++ DFS 
    PUSH EDX
    PUSH EBX
    PUSH ECX
    INVOKE DFS, 1, ADDR board, 0    ;color red, board address, arrayIndex 0
    POP ECX
    POP EBX
    POP EDX
    CMP EAX,1       ;if eAx == 1 winning path found
    JNE Continue        ;eAx != 1 no valid path...continue game

  ;the rest of this code removed for brevity

END_GAME:

Retn
main ENDP

My C ++ záhlaví souboru vypadá takto:

C++ header file DFSAlgorithm.h

#ifndef DFSAlgorithm_H
#define DFSAlgorithm_H
extern C void printSomething();
extern C int DFS(int color, int hex_array[], int array_index);

#endif

A můj C ++ souboru CPP (ve zkratce) vypadá takto:

#include stdafx.h
#include<iostream>
#include<stack>
#include DFSAlgorithm.h//include definition of class DFSAlgorithm
using namespace std;

int adjacency[6];
stack<int> path; //stack to hold the last hex visited

//test printsomething
extern C void printSomething(){
    cout<<Goobers2014;
}

//First call of DFS always starts with array_index ==  0
extern C int DFS(int color, int hex_array[], int array_index){    

    if (hex_array[array_index] == color){ //if hex has an appropriately colored stone

        hex_array[array_index] += 3;    //mark the hex as visited

        path.push(array_index); //push hex onto path stack
    }
    if ((color == 1 && array_index % 11 == 10 && hex_array[array_index] == 4) || 
        (color == 2 && array_index / 11 == 10 && hex_array[array_index] == 5)){

    return 1; //winner base case==>reached the other side
    }

//If a visited/unvisited hex has a stone of correct color==> search adjacent hexes
if ((color == 1 &&  hex_array[array_index] == 4)  || 
    (color == 2  &&  hex_array[array_index] == 5)){

    //get adjacencies
    //removed from code for brevity
        }

    /*Initialize adjacentHexes to zero: if == 0 after all 6 adjacencies are 
    checked it is a dead end as there are no unvisited adjacent hexes with 
    the correct color stone*/
    int adjacentHexes = 0;  
        for(int b = 0; b < 6; b++){//traverse adjacency array of passed in index

//if one of the adjacent hexes has a red/blue stone
    if((color == 1 && hex_array[adjacency[b]] == color) ||
    (color == 2 && hex_array[adjacency[b]] == color )){ 

        adjacentHexes++;    //increment adjacentHexes count

        hex_array[adjacency[b]] += 3;   //mark the hex as visited

        path.push(adjacency[b]); //push visited adjacent hex onto path 

        //recursively call DFS with that adjacent hex index
                return DFS(color, hex_array,adjacency[b]);  

                }
            }
        //If adjacentHexes == 0 ==> dead-end
                if(adjacentHexes == 0 && path.size() > 1){

        path.pop();//pop the top hex from the stack if stack > 1

        //recursive call of DFS with the new top red/blue hex
        return DFS(color, hex_array,path.top());
                    }
        if(adjacentHexes == 0 && path.size() == 1){//back to Row 0/Column 0

                    //make the array_index = the top of the path stack      
//+++++this line generates a deque iterator not dereferenceable error++++++++++++++
                    array_index = path.top();

                    //pop remaining element from the stack so path is now zero
                    path.pop();
                }
    }
        //if checking for a red path and path is empty
        if (color == 1 ){

            //search remaining column 0 hexes for unvisited red hex 
            for(array_index ; array_index <= 99; ){ 

                //recursively call DFS with next Column 0 hex
                return DFS(color, hex_array, array_index + 11);
                }
        }

        //if checking for a blue path and path is empty
        if (color == 2){

        //search remaining row 0 hexes for unvisted blue hex
            for(array_index ; array_index <= 9; ){

                //recursively call DFS with next Row 0 hex
                return DFS(color, hex_array, array_index + 1);
                }
            }
            //Traverse hex_array and reset all visited hexes to unvisited
            for(int a = 0; a < 121; a++){
                if(hex_array[a] >= 4)//if hex has been visited
                    hex_array[a] -= 3;//remove visited designation  
            }

        return -1;//return false as no path exists

}

Nejsem si jistý, proč to nedokáže na trati, kde jsem nastavit array_index na path.top () a pak se pop vršek zásobníku, protože to fungovalo v pořádku, když celý soubor byl v jazyce C ++, takže si nejsem jistý, proč je teď nefunguje. Předpokládám, že to má co do činění s tím, jak je C ++ funkce přístupu k array_index.

Položena 21/03/2014 v 17:01
zdroj uživatelem
V jiných jazycích...                            


1 odpovědí

hlasů
3

Došlo k chybě vám řekne tento problém velmi jasně; Máte žádnou definici globální funkce ShowBoard.

Pokud jste čekali DFSAlgorithm::showBoard‚s definicí, pak budete zklamáni ze dvou důvodů:

  1. DFSAlgorithm::showBoardnení globální funkcí, ale funkce člena (na které instance DFSAlgorithmby to fungovat?);
  2. showBoarda ShowBoardjsou vysvětleny jinak.

Pokud jde o mainVaše C ++ soubor by neměl definovat main, protože vaše sestavení soubor dělá, a chcete pouze jednu takovou definici přes svého programu.

Odpovězeno 21/03/2014 v 17:05
zdroj uživatelem

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more