[C++](Codeblocks) przypisanie wartosci zmiennej z rej pod adres
Panel użytkownika
Nazwa użytkownika:
Hasło:
Nie masz jeszcze konta?
Zarejestruj się!

[C++](Codeblocks) przypisanie wartosci zmiennej z rej pod adres

AutorWiadomość
Temat założony przez niniejszego użytkownika
[C++](Codeblocks) przypisanie wartosci zmiennej z rej pod adres
» 2018-02-02 08:27:13
Witam

Mam kłopot z kodem c++ napisanym w borland 4.5 z wstawkami asemblerowymi, chciałem go uruchomić w codeblocks 17.12, żeby program odpalał się po Windows 10.Dużo błędów poprawiałem, ale jeszcze zostały.Codeblocks wywala takie błedy:
undefined reference to `a'
undefined reference to `a1'
undefined reference to `b1'
undefined reference to `c1'

Kod:
C/C++
/*******************************************************************************
********************************************************************************
******************************** PROGRAM - PRACA DYPLOMOWA *********************
************************************* Sieci Neuronowe **************************
*******************************************************************************/

#include <dos.h>
#include <conio.h>
#include <stdio.h>
#include <iostream>
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>

/*******************************************************************************
********************************* zadeklarowanie zmiennych globalnych **********
*******************************************************************************/

int x, y, z; //informacje o polozeniu kursora myszy
bool stan[ 4 ]; //informacje o stanie przyciskow
int znak; //zczytywanie znaku z klawiatury, zmienna sterujaca

/*******************************************************************************
************************************** FUNKCJE *********************************
********************************************************************************
********************************* wyswietla kursor myszy ***********************
********************************************************************************/

void wyswietl_kursor()
{
    asm
    (
    "mov %ax,0x0001;" //zmienna w zapisie szesnastkowym
    "int $0x33;" //przerwanie 33 obslugujace mysz
    );
}

/*******************************************************************************
******************************** ukrywa kursor myszy ***************************
*******************************************************************************/

void ukryj_kursor()
{
    asm
    (
    "mov %ax,0x0002;" //nadaje wartosc rejestrowi
    "int $0x33;"
    );
}

/*******************************************************************************
*************** funkcja ustawiajaca palete na kolejne poziomy szarosci *********
***************** !!!tylko pierwszych 6 kolorow!!!******************************
********************** pozostale sa bez zmian **********************************
*******************************************************************************/

void paleta_szarosc()
{
    setrgbpalette( 1, 0, 0, 0 ); //czarny
    setrgbpalette( 2, 15, 15, 15 );
    setrgbpalette( 3, 25, 25, 25 );
    setrgbpalette( 4, 35, 35, 35 );
    setrgbpalette( 5, 45, 45, 45 );
    setrgbpalette( 6, 63, 63, 63 ); //bialy
    setbkcolor( 4 ); //szary tla
}

/*******************************************************************************
********************************** Funkcja rysujaca cieniowana ramke ***********
*********************************** jako wspolrzedne podajemy rogi ramki *******
*******************************************************************************/

void ramka( int x1, int y1, int x2, int y2 )
{
    setcolor( 2 );
    line( x1, y1, x2, y1 );
    line( x2, y1, x2, y2 );
    line( x2, y2, x1, y2 );
    line( x1, y2, x1, y1 );
    setcolor( 5 );
    line( x1 - 1, y1 - 1, x2 - 1, y1 - 1 );
    line( x2 - 1, y1 + 1, x2 - 1, y2 - 1 );
    line( x2 - 1, y2 - 1, x1 - 1, y2 - 1 );
    line( x1 - 1, y2 - 1, x1 - 1, y1 - 1 );
}

/******************************************************************************
**************************Funkcja rysujaca cieniowany, wypukly klawisz ********
********************* jako wspolrzedne podajemy rogi klawisza ****************/

void klawisz_wycisniety( int x1, int y1, int x2, int y2 )
{
    ukryj_kursor();
    setcolor( 5 );
    line( x1, y1, x2, y1 );
    line( x1, y2, x1, y1 );
    setcolor( 2 );
    line( x2, y2, x1, y2 );
    line( x2, y1, x2, y2 );
    wyswietl_kursor();
   
}

/*******************************************************************************
*************************** Funkcja rysujaca cieniowany , wklesly klawisz ******
********************** jako wspolrzedne podajemy rogi klawisza *****************
*******************************************************************************/

void klawisz_wcisniety( int x1, int y1, int x2, int y2 )
{
    ukryj_kursor();
    setcolor( 2 );
    line( x1, y1, x2, y1 );
    line( x1, y2, x1, y1 );
    setcolor( 5 );
    line( x2, y2, x1, y2 );
    line( x2, y1, x2, y2 );
    wyswietl_kursor();
   
}

/*******************************************************************************
********************** Procedura sprawdzajaca czy mysz jest ********************
**********************************zainstalowana*********************************
*******************************************************************************/

void mysz()

{
    int a;
    asm
    (
    "mov %ax,0x000;"
    "int $0x33;"
    "mov a,%ax" //z ax do a czy mysz jest zainst 1 jezeli nie to 0
    );
    if( a == 1 )
         printf( "Mysz wykryta...OK" );
    else
    {
        printf( "Sorry!!! Nie masz zainstalowanej myszy!" );
        exit;
    }
}

/*******************************************************************************
************************************* Stan myszy *******************************
***************************** a - czy klawisz byl wcisniety ********************
************************************* b - polozenie X **************************
************************************* c - polozenie Y **************************
********************************************************************************
********************************************************************************/

void stan_myszy( int * b, int * c, int * a )
{
    int a1, b1, c1;
   
    asm(
    "mov %ax,0x0003;"
    "int $0x33;"
    "mov a1,%bx;" //poloz w x
    "mov b1,%cx;" // polozenie w osi y
    "mov c1,%dx;" // wartosc klawisza myszy
    );
   
    * a = a1; //wartosc zmiennej z rej a1 pod adres a
    * b = b1;
    * c = c1;
   
   
}

/*******************************************************************************
************Funkcja rysujaca wycieniowany klawisz, reagujacy na mysz************
*********************** jako wspolrzedne podajemy rogi *************************
********************************************************************************/

void klawisz( int x1, int y1, int x2, int y2, bool * stan )
{
    int x, y, z;
    stan_myszy( & x, & y, & z ); //zwraca wartosc myszy
    if( * stan == false ) //stan klawisza true wcisniety, falsz nie wcisniety
    {
        if(( x > x1 ) &&( x < x2 ) &&( y > y1 ) &&( y < y2 ) &&( z == 1 ) ) //wcisniety
        {
            klawisz_wycisniety( x1, y1, x2, y2 ); //wycisniety
            * stan = true;
            delay( 300 );
        };
    }
    else
    {
        if(( x > x1 ) &&( x < x2 ) &&( y > y1 ) &&( y < y2 ) &&( z == 1 ) )
        {
            klawisz_wcisniety( x1, y1, x2, y2 );
            * stan = false;
            delay( 300 );
        };
    };
};

/*******************************************************************************/
/***************procedura czyszczaca nieregularny obszar ekranu*****************/
/*******************************************************************************/

void clear_obszar()
{
    ukryj_kursor();
    // jasna nieregularna ramka
    setcolor( 5 );
    line( 116, 16, 116, 221 );
    line( 116, 221, 16, 221 );
    line( 16, 221, 16, 466 );
    line( 16, 466, 626, 466 );
    line( 626, 466, 626, 56 );
    line( 626, 56, 441, 56 );
    line( 441, 56, 441, 16 );
    line( 441, 16, 116, 16 );
   
    // wymazywanie wszystkiego ze srodka
   
    setfillstyle( 0, 0 );
    floodfill( 120, 20, 5 );
   
    // cieniowana, nieregularna ramka
   
    setcolor( 1 );
    line( 115, 15, 115, 220 );
    line( 115, 220, 15, 220 );
    line( 15, 220, 15, 465 );
    line( 15, 465, 625, 465 );
    line( 625, 465, 625, 55 );
    line( 625, 55, 440, 55 );
    line( 440, 55, 440, 15 );
    line( 440, 15, 115, 15 );
   
    setcolor( 5 );
    line( 116, 16, 116, 221 );
    line( 116, 221, 16, 221 );
    line( 16, 221, 16, 466 );
    line( 16, 466, 626, 466 );
    line( 626, 466, 626, 56 );
    line( 626, 56, 441, 56 );
    line( 441, 56, 441, 16 );
    line( 441, 16, 116, 16 );
    wyswietl_kursor();
};

/*******************************************************************************/
/*************************** uproszczony schemat neuronu************************/
/*******************************************************************************/

void schemat_n( int x, int y )
{
    setcolor( 14 );
    rectangle( x, y, x + 50, y + 80 );
    setcolor( 11 );
    circle( x + 25, y + 25, 20 );
    setcolor( 9 );
    line( x, y + 50, x + 50, y + 50 );
    line( x, y + 50, x + 25, y + 80 );
    line( x + 50, y + 50, x + 25, y + 80 );
}

/******************************************************************************/
/************************* Schemat budowy sieci neuronow **********************/
/******************************************************************************/

void siec()
{
    ukryj_kursor();
   
    setcolor( 1 );
   
    outtextxy( 185, 30, "SCHEMAT SIECI NEURONOWEJ" );
   
    setcolor( 2 );
    outtextxy( 120, 60, "zastosowano konwencje ze schematu neuronu" );
   
    outtextxy( 250, 100, "WEJSCIA" );
   
    outtextxy( 133, 175, "warstwy" );
    outtextxy( 125, 185, "wejsciowe" );
   
    outtextxy( 75, 285, "wagi" );
   
    line( 225, 110, 225, 145 );
    line( 325, 110, 325, 145 );
   
    schemat_n( 200, 150 );
    schemat_n( 300, 150 );
    schemat_n( 150, 250 );
    schemat_n( 250, 250 );
    schemat_n( 350, 250 );
    schemat_n( 250, 350 );
   
    setcolor( 2 );
   
    line( 275, 435, 275, 450 );
    outtextxy( 250, 450, "WYJSCIE" );
   
    outtextxy( 450, 275, "warstwa" );
    outtextxy( 455, 285, "ukryta" );
   
    outtextxy( 350, 375, "warstwa" );
    outtextxy( 340, 385, "wyjsciowa" );
   
    setcolor( 2 );
   
    line( 175, 250, 225, 230 );
    line( 275, 250, 225, 230 );
    line( 375, 250, 225, 230 );
   
    line( 175, 250, 325, 230 );
    line( 275, 250, 325, 230 );
    line( 375, 250, 325, 230 );
   
    line( 275, 350, 175, 330 );
    line( 275, 350, 275, 330 );
    line( 275, 350, 375, 330 );
   
    wyswietl_kursor();
    delay( 300 );
   
    znak = 0;
    z = 0;
   
    do
    {
       
        stan_myszy( & x, & y, & z );
        if( kbhit() ) znak = getch(); //czytanie klawisza
       
        if(( x > 7 ) &&( y > 60 ) &&( x < 97 ) &&( y < 100 ) &&( z == 1 ) ) znak = 27;
       
    }
    while( znak != 27 );
   
    clear_obszar();
    klawisz_wycisniety( 7, 60, 97, 100 );
    delay( 300 );
}

/*******************************************************************************/
/************************ Schemat budowy i opis dzia³ania neuronu **************/
/*******************************************************************************/

void neuron()
{
    setcolor( 1 );
    outtextxy( 120, 30, "NEURON - BUDOWA I DZIALANIE" );
    setcolor( 2 );
    outtextxy( 120, 60, "Schemat Neuronu zostal opracowany przez McCullocha i Pittsa" );
    outtextxy( 120, 70, "w 1943 roku i oparty zostal na budowie komorki nerwowej," );
   
    setcolor( 14 ); //rysowanie schematu neuronu(zolty)
    rectangle( 200, 200, 410, 320 );
   
    setcolor( 2 );
   
    rectangle( 220, 220, 240, 300 );
    rectangle( 220, 240, 240, 260 );
    rectangle( 220, 260, 240, 280 );
   
    //wagi polaczen
    line( 180, 230, 215, 230 );
    line( 180, 250, 215, 250 );
    line( 180, 270, 215, 270 );
    line( 180, 290, 215, 290 );
   
    //opisy wag polaczen
    outtextxy( 163, 228, "X1" );
    outtextxy( 163, 248, "X2" );
    outtextxy( 163, 268, "X3" );
    outtextxy( 163, 288, "X4" );
    outtextxy( 140, 300, "wejscia" );
   
    outtextxy( 150, 180, "wagi polaczen" );
   
    line( 228, 193, 228, 215 );
   
    outtextxy( 224, 228, "W1" );
    outtextxy( 224, 248, "W2" );
    outtextxy( 224, 268, "W3" );
    outtextxy( 224, 288, "W4" );
   
    line( 245, 230, 280, 250 );
    line( 245, 250, 280, 255 );
    line( 245, 270, 280, 265 );
    line( 245, 290, 280, 270 );
   
    outtextxy( 295, 257, "SUMA" ); //w kole
    circle( 310, 260, 20 );
   
    outtextxy( 338, 251, "S" );
    line( 330, 260, 350, 260 );
   
    // trojkat
    line( 360, 245, 360, 275 );
    line( 360, 245, 390, 260 );
    line( 360, 275, 390, 260 );
    outtextxy( 360, 257, "f(s)" );
   
    line( 370, 248, 380, 190 );
    outtextxy( 280, 180, "funkcja aktywacji neuronu" );
   
    line( 400, 260, 450, 260 );
    outtextxy( 455, 257, "x" );
   
    outtextxy( 435, 300, "wyjscie" );
    outtextxy( 170, 330, "schemat budowy pojedynczego neuronu" );
   
    outtextxy( 45, 355, "Do wejsc doprowadzane sa sygnaly dochodzace z neuronow warstwy" );
    outtextxy( 30, 365, "poprzedniej. Kazdy sygnal mnozony jest przez odpowiadajaca mu wartosc" );
    outtextxy( 30, 375, "liczbowa zwana waga. Wplywa ona na percepcje danego sygnalu wejsciowego" );
    outtextxy( 30, 385, "i jego udzial w tworzeniu sygnalu wyjsciowego przez neuron." );
    outtextxy( 45, 395, "Waga moze byc pobudzajaca (dodatnia) lub opuzniajaca (ujemna),jezeli" );
    outtextxy( 30, 405, "nie ma polaczenia miedzy neuronami to waga jest rowna zero. Zsumowanie" );
    outtextxy( 30, 415, "iloczyny sygnalow i wag stanowia argument funkcji aktywacji neuronu." );
   
    delay( 300 );
    znak = 0;
    z = 0;
   
    do
    {
        stan_myszy( & x, & y, & z );
        if( kbhit() ) znak = getch(); //czytanie klawisza
       
        if(( x > 7 ) &&( y > 10 ) &&( x < 97 ) &&( y < 50 ) &&( z == 1 ) ) znak = 27;
       
    }
    while( znak != 27 );
   
    clear_obszar();
    klawisz_wycisniety( 7, 10, 97, 50 );
    delay( 300 );
}
/********************************************************************************
********************* wyswietla informacje pomocy do programu *******************
*******************************************************************************/

void pomoc()
{
    setcolor( 1 );
    outtextxy( 120, 30, "POMOC - Program Sieci Neuronowe" );
    setcolor( 2 );
    outtextxy( 120, 60, "Program sieci neuronowe, jest interaktywna prezentacja" );
    outtextxy( 120, 70, "zagadnien zwiazanych z sieciami neuronowymi" );
    outtextxy( 120, 80, "Pozwala na zapoznanie sie z podstawami budowy neuronu" );
    outtextxy( 120, 90, "jak i caloscia sieci neuronowych." );
    outtextxy( 120, 110, "Poszczegolne zagadnienia sa omawiane w sekcjach programu" );
    setcolor( 1 );
    outtextxy( 120, 130, "SEKCJA I - NEURON " );
   
    setcolor( 1 );
    outtextxy( 120, 150, "SEKCJA II - SIECI " );
   
    znak = 0;
    z = 0;
    do
    {
        stan_myszy( & x, & y, & z );
        if( kbhit() ) znak = getch(); //czytanie klawisza
       
        if(( x > 452 ) &&( y > 7 ) &&( x < 541 ) &&( y < 43 ) &&( z == 1 ) ) znak = 27;
       
    }
    while( znak != 27 );
   
    clear_obszar();
    klawisz_wycisniety( 452, 7, 541, 43 );
    delay( 300 );
}

/******************************************************************************/
/******************** PROGRAM GLOWNY ******************************************/
/******************************************************************************/

int main()
{
    int gdriver, gmode; //inicjalizacja zmiennych pomocniczych
    mysz();
    gdriver = DETECT; //sterownik,tryb
    initgraph( & gdriver, & gmode, "C:\\Program Files (x86)\\CodeBlocks\\MinGW\\Include\\" );
    wyswietl_kursor();
    paleta_szarosc();
   
    /******************************************************************************
    /******************* rysowanie glownego okna **********************************
    /******************************************************************************/
   
    // cieniowana, nieregularna ramka
   
    setcolor( 1 );
   
    line( 115, 15, 115, 220 );
    line( 115, 220, 15, 465 );
    line( 15, 220, 15, 465 );
    line( 625, 465, 625, 55 );
    line( 625, 55, 440, 55 );
    line( 440, 55, 440, 15 );
    line( 440, 15, 115, 15 );
   
    setcolor( 5 );
   
    line( 116, 16, 116, 221 );
    line( 116, 221, 16, 221 );
    line( 16, 221, 16, 466 );
    line( 16, 466, 626, 466 );
    line( 626, 466, 626, 56 );
    line( 626, 56, 441, 56 );
    line( 441, 56, 441, 16 );
    line( 441, 16, 116, 16 );
   
    //klawisze z lewej strony
   
    klawisz_wycisniety( 3, 3, 637, 477 );
    klawisz_wcisniety( 5, 5, 100, 205 );
    klawisz_wycisniety( 7, 10, 97, 50 );
    klawisz_wycisniety( 7, 60, 97, 100 );
    klawisz_wycisniety( 7, 110, 97, 150 );
    klawisz_wycisniety( 7, 160, 97, 200 );
   
    // klawisze sterujace POMOC i EXIT
   
    bool ster[ 2 ]; //zmienna lokalna informacje o stanie klawiszy POMOC I EXIT
   
    klawisz_wcisniety( 450, 5, 635, 45 );
    klawisz_wycisniety( 452, 7, 541, 43 );
    klawisz_wycisniety( 543, 7, 633, 43 );
   
    setcolor( 1 );
   
    outtextxy( 475, 22, "POMOC" );
    outtextxy( 575, 22, "EXIT" );
    outtextxy( 215, 19, "PRACA DYPLOMOWA" );
    outtextxy( 125, 36, "PREZENTACJA BUDOWY SIECI NEURONOWYCH" );
   
    ster[ 1 ] = false;
   
    outtextxy( 28, 28, "NEURON" );
    outtextxy( 32, 78, "SIEC" );
   
    /*******************************************************************************
    /************************* petla glowna programu *******************************
    *******************************************************************************/
   
    do
    {
        stan_myszy( & x, & y, & z );
       
        if(( x > 452 ) &&( y > 7 ) &&( x < 541 ) &&( y < 43 ) &&( z == 1 ) )
        {
            klawisz_wcisniety( 452, 7, 541, 43 );
            delay( 300 );
            clear_obszar();
            pomoc();
        }
       
        if(( x > 7 ) &&( y > 10 ) &&( x < 97 ) &&( y < 50 ) &&( z == 1 ) )
        {
            klawisz_wcisniety( 7, 10, 97, 50 );
            delay( 300 );
            clear_obszar();
            neuron();
        }
       
        if(( x > 7 ) &&( y > 60 ) &&( x < 97 ) &&( y < 100 ) &&( z == 1 ) )
        {
            klawisz_wcisniety( 7, 60, 97, 100 );
            delay( 300 );
            clear_obszar();
            siec();
        }
       
        klawisz( 7, 110, 97, 150, & stan[ 2 ] );
        klawisz( 7, 160, 97, 200, & stan[ 3 ] );
        klawisz( 452, 7, 541, 43, & stan[ 0 ] );
        klawisz( 543, 7, 633, 43, & stan[ 1 ] );
    }
   
    while( !( kbhit() ) &&( !stan[ 1 ] ) );
   
    closegraph();
   
};

P-169185
» 2018-02-02 08:30:02
z przerwań BIOS/DOS raczej nie skorzystasz w windows powyżej win98. Więc adaptacja tego kodu z tymi wstawkami "asm" raczej nie wchodzi w grę. Windows Xp już Dosa nie miał.
P-169186
Temat założony przez niniejszego użytkownika
» 2018-02-02 08:49:03
Rzecz w tym że w Windows XP mi program działał wersja 16-bitowa, a teraz ma Windows 10 64-bitowy i już się nie odpala.A czy nie ma jakiegoś emulatora pod Windows 10 ?
P-169187
» 2018-02-02 09:09:16
XP mi program działał wersja 16-bitowa,
hmm. Działanie przerwań w programie użytkownika pod Windowsami z serii NT jest dla mnie niespodzianką. To może ktoś bardziej obeznany w temacie się wypowie.
#include <graphics.h> to nie jest czasami nagłówek typowy dla borlanda??
P-169188
» 2018-02-02 10:21:58
Czy to są wszystkie błędy jakie wypluwa Ci codeblocks? Bo wydaje mi się, że połowa tych funkcji/headerów jest dostarczana jedynie wraz Boarldem.


Rzecz w tym że w Windows XP mi program działał wersja 16-bitowa
Mówisz o wersji, którą pobrałeś czy udało Ci się skompilować na Windows XP?
P-169190
» 2018-02-02 10:35:46
@mateczek, programy DOS-owe uruchamiane są w tzw. wirtualnej maszynie DOS-a (VDM). Przerwania są wyłapywane przez system i odpowiednio obsłużone/zasymulowane.
P-169191
» 2018-02-02 11:21:42
How to include graphics.h in CodeBlocks?
http://www.codewithc.com/how-to-include-graphics-h-in-codeblocks/
https://www.youtube.com/watch?v=fWmis4uVCHg
P-169192
» 2018-02-02 12:55:09
A czy nie ma jakiegoś emulatora pod Windows 10 ?
Może DOSBox?
P-169194
« 1 » 2 3
 Strona 1 z 3Następna strona