C++ példákat az Apucinak

C++ példákat az Apucinak
2004-02-18T18:46:15+01:00
2004-05-28T20:49:03+02:00
2022-11-01T15:40:35+01:00
  • Nos ,hát mint tanár a gyerekeknek biztos nem menne ,de mint programozó a programozónak egész biztos ,hogy menne


    2.Tegye fel a kezét aki progarmozónak valja magát(na most én nem teszem fel az enyémet).


    Van egy kis anomália abban, amit mondasz.

    De mindegy, mi fel vagyunk izgatva. Mikor kezdődik a kurzus?
    Mutasd a teljes hozzászólást!
  • Részemről:
    1. Amennyiben kimerítő választ adsz, OK. Igaz, azt ígérted, hogy az általunk adott feladatokat fogod megoldani, de megemlítetted, hogy mivel foglalkozol mostanában, tehát már elég sok tudást felhalmozhattál, sokat tapasztalhattál erről az algoritmusról. Ebből kérnénk néhány cseppecskét...
    2. (nem teszem fel, úgyhogy vesézd ki a témát)
    3. nosza
    Mutasd a teljes hozzászólást!
  • Nos ,hát mint tanár a gyerekeknek biztos nem menne ,de mint programozó a programozónak egész biztos ,hogy menne.

    Pár kitételem viszont van ,mielőtt neki látnánk a dolognak.
    1.Nem ér nevetni.
    2.Tegye fel a kezét aki progarmozónak valja magát(na most én nem teszem fel az enyémet).
    3.Megpróbálom elmondani mit csinál az algoritmus ,de nem erre a kódra alapozom mondani valómat.

    Ki ért egyet?
    Mutasd a teljes hozzászólást!
  • Na most megint nem látjuk egy hónapig.
    Mutasd a teljes hozzászólást!
  • Ha neked sokáig tart elmagyarázni egy A*-ot, akkor veled van a baj, vagy egyszerűen magad sem érted.:) Elég egyszerű algoritmusról van szó.
    Mutasd a teljes hozzászólást!
  • Na, de hogy ne offoljunk annyit , az eredeti kérés az volt, hogy adjunk neked példákat, amiket megoldasz.
    Tessék, egy egyszerű példa: írj C-ben egy függvényt, ami a paraméterként átadott valós szám egészre kerekített értékét adja vissza.
    (csalni nem ér, csak a saját víztározódat használhatod - ha sikerül megoldanod, úgy vesszük, hogy csaltál )
    Mutasd a teljes hozzászólást!
  • Hogyan jött ez a példa? Csak úgy találtad, aztán megtetszett, vagy direkt valami bonyolult (-nak tűnő) algorimust választottál?
    Mutasd a teljes hozzászólást!
  • Időnk, mint a tenger
    Mutasd a teljes hozzászólást!
  • Elég sokáig tartana ezt elmagyarázni.
    Mutasd a teljes hozzászólást!


  • Ennyi.

    Egyáltalán tudod hogy mit csinál az az algoritmus (hamár egyszer nem te írtad)?
    Mutasd a teljes hozzászólást!
  • Egyébbként kikérem magamnak ezt a 14 évet

    A helyedben ezt nem mondtam volna.

    mesterséges inteligenciát fejlesztek
    ...
    pathfinding cuccosokat nyomom
    ...
    egy magyar szót sem spékeltem bele a programjaimba

    Abból is láthatnánk néhány sort?
    Halálkomolyan mondom, kíváncsi lennék rá! (Nem fogok rajta)
    Mutasd a teljes hozzászólást!
  • Egyébként nekem is gyanús volt a változónevek megválasztása, egy magyar hangzású sem volt köztük, bár ez nem kizáró ok


    Ezt imádom!

    Képzeld én idáig egy magyar szót sem spékeltem bele a programjaimba.Én angolul tanultam meg programozni(nem oroszul,nem arabul,nem japánul,és legfőképp nem magyarul!).Tudom ,tudom most jön az a válasz ,hogy:valószinűleg ezért nem tud helyesen irni a kis csávó.Már megint sikerült a billyentyűzetetekről le lopnom a szót.

    Ugye?
    Mutasd a teljes hozzászólást!
  • Igen ,igen az igaz ,hogy más oldaláról van.Azt hittem már sosem jöttök rá ,de nem erről az oldalról van.Ez egy másik oldal.

    Igen,igen az is igaz ,hogy mostanában mesterséges inteligenciát fejlesztek(most azzal jöttök majd ,hogy inkább magamnak fejlesszek inteligenciát a modorom végett ,de szerencse ,hogy én még hamarabb elkaptam a választ mielőtt még leirtátok volna).Na szóval most a pathfinding cuccosokat nyomom ,ez most nálam a divat.Egyébbként kikérem magamnak ezt a 14 évet.Annál azért valamicskével több vagyok.

    A másik feladatot valaki már megoldotta?
    Mutasd a teljes hozzászólást!
  • Azért szerintem az is elég gyanús, hogy egy 14 éves emberke A* algoritmussal szórakozik szabadidejében.:)
    Mutasd a teljes hozzászólást!
  • Ez lemaradt a hozzászólásod elejéről:
    "Kedves gyerekek! Apuci ma a Ctrl-C, Ctrl-V használatát mutatja be nektek!"

    (Egyébként nekem is gyanús volt a változónevek megválasztása, egy magyar hangzású sem volt köztük, bár ez nem kizáró ok)
    Mutasd a teljes hozzászólást!
  • Hogy mivel foglalkozol?
    Azzal, hogy más oldalakról vágdosol ide kódokat, sugallva, hogy van közöd hozzá:
    http://cpcug.org/user/scifair/Preygel/Preygel.html
    Mutasd a teljes hozzászólást!
  • Szevasztok!

    Képzeljétek vissza tértem hosszú nyaramból.Most úgy mint mindig ma is kinozni foglak benneteket.Kezdem is ,most ide kirakok neketek egy óriási forráskódot.Na most ha megfejtitek miről is lehet szó ,akkor valószinűleg rájöttők mivel is foglalkozom mostanában.

    Tessék C++ apucik:

    #include "AStar.hpp"
    #include <iostream>
    using namespace std;
    bool operator == (const Point& a, const Point& b )
    {
    return (a.x==b.x)&&(a.y==b.y);
    }
    bool operator > ( const Node& a, const Node& b ){
    return (a.fVal) > (b.fVal);
    }
    bool operator == ( const Node& a, const Node& b ){
    return (a.coord==b.coord);
    }
    bool operator < ( const Node& a, const Node& b ){
    return (a.fVal) < (b.fVal);
    }
    bool operator != ( const Node& a, const Node& b ){
    return !(a.coord==b.coord);
    }
    greater<Node> comp;
    bool m_Diag=false;

    int AStar::doesContain(NodeQueue open, Node n)
    {
    for (int x=0;x<open.size();x++)
    {
    if (open[x]==n)
    return x;
    }
    return -1;
    }
    Path AStar::run(Map map, Heuristic * h, float gv, void (__cdecl *func )(Node ex) )
    {
    m_Diag=false;
    NodeQueue open;
    NodeQueue closed;
    Path path;
    Node start=map.start;
    Node goal=map.goal;
    start.cost=getMapAt(map, start.coord.x, start.coord.y);
    start.gVal=0;
    start.hVal=h->run(start,goal);
    start.fVal=gv*(real)start.gVal+(1-gv)*start.hVal;
    start.parentCoord.x=-1;
    start.parentCoord.y=-1;
    open=push(open,start);
    Node n;
    int newg;
    NodeList children;
    Node child;
    int inOpen;
    int inClosed;
    int expanded=0;
    while (!open.empty())
    {
    expanded++;
    n = open.front();
    if (func!=NULL)
    (*func)(n);
    pop_heap( open.begin(), open.end(), comp);
    open.pop_back();
    closed.push_back(n);
    if (n==goal)
    {
    path=buildPath(open,closed,n);
    path.expanded=expanded;
    break;
    }
    else
    {
    children.clear();
    children=getChildren(map, n);
    while (!children.empty())
    {
    child=children.front();
    children.pop_front();
    newg=n.gVal+child.cost;
    inClosed=doesContain(closed, child);
    inOpen=doesContain(open, child);
    if (inClosed!=-1)
    {
    child=closed[inClosed];
    }
    if (inOpen!=-1)
    {
    child=open[inOpen];
    }
    if ((newg<child.gVal)||((inOpen==-1)&&(inClosed==-1)))
    {
    child.parentCoord=n.coord;
    child.gVal=newg;
    child.hVal=h->run(child, goal);
    child.fVal=gv*(real)child.gVal+(1-gv)*child.hVal;
    if (inClosed!=-1)
    {
    closed.erase(closed.begin()+inClosed);
    }
    if (inOpen==-1)
    {
    open=push(open,child);
    }
    }
    }
    }
    }
    return path;
    }
    NodeQueue AStar::push(NodeQueue open,Node n)
    {
    open.push_back( n );
    push_heap( open.begin(), open.end(), comp );
    return open;
    }
    byte AStar::getMapAt(Map map, byte x, byte y)
    {
    return map.map[x+y*map.width];
    }
    NodeList AStar::getChildren(Map map, Node p)
    {
    NodeList nl;
    Node c;
    if (p.coord.x>0)
    {
    if (getMapAt(map,p.coord.x-1,p.coord.y)!=0)
    {
    c.coord.x=p.coord.x-1;
    c.coord.y=p.coord.y;
    c.parentCoord=p.coord;
    c.cost=getMapAt(map,c.coord.x,c.coord.y);
    nl.push_front(c);
    }
    }
    if (p.coord.x<map.width-1)
    {
    if (getMapAt(map,p.coord.x+1,p.coord.y)!=0)
    {
    c.coord.x=p.coord.x+1;
    c.coord.y=p.coord.y;
    c.parentCoord=p.coord;
    c.cost=getMapAt(map,c.coord.x,c.coord.y);
    nl.push_front(c);
    }
    }
    if (p.coord.y<map.height-1)
    {
    if (getMapAt(map,p.coord.x,p.coord.y+1)!=0)
    {
    c.coord.x=p.coord.x;
    c.coord.y=p.coord.y+1;
    c.parentCoord=p.coord;
    c.cost=getMapAt(map,c.coord.x,c.coord.y);
    nl.push_front(c);
    }
    }
    if (p.coord.y>0)
    {
    if (getMapAt(map,p.coord.x,p.coord.y-1)!=0)
    {
    c.coord.x=p.coord.x;
    c.coord.y=p.coord.y-1;
    c.parentCoord=p.coord;
    c.cost=getMapAt(map,c.coord.x,c.coord.y);
    nl.push_front(c);
    }
    }
    if (m_Diag)
    {
    if ((p.coord.x>0)&&(p.coord.y>0))
    {
    if (getMapAt(map,p.coord.x-1,p.coord.y-1)!=0)
    {
    c.coord.x=p.coord.x-1;
    c.coord.y=p.coord.y-1;
    c.parentCoord=p.coord;
    c.cost=getMapAt(map,c.coord.x,c.coord.y);
    nl.push_front(c);
    }
    }
    if ((p.coord.x>0)&&(p.coord.y<map.height-1))
    {
    if (getMapAt(map,p.coord.x-1,p.coord.y+1)!=0)
    {
    c.coord.x=p.coord.x-1;
    c.coord.y=p.coord.y+1;
    c.parentCoord=p.coord;
    c.cost=getMapAt(map,c.coord.x,c.coord.y);
    nl.push_front(c);
    }
    }
    if ((p.coord.x<map.width-1)&&(p.coord.y<map.height-1))
    {
    if (getMapAt(map,p.coord.x+1,p.coord.y+1)!=0)
    {
    c.coord.x=p.coord.x+1;
    c.coord.y=p.coord.y+1;
    c.parentCoord=p.coord;
    c.cost=getMapAt(map,c.coord.x,c.coord.y);
    nl.push_front(c);
    }
    }
    if ((p.coord.x<map.width-1)&&(p.coord.y>0))
    {
    if (getMapAt(map,p.coord.x+1,p.coord.y-1)!=0)
    {
    c.coord.x=p.coord.x+1;
    c.coord.y=p.coord.y-1;
    c.parentCoord=p.coord;
    c.cost=getMapAt(map,p.coord.x-1,p.coord.y);
    nl.push_front(c);
    }
    }
    }
    return nl;
    }
    Path AStar::buildPath(NodeQueue open, NodeQueue closed, Node goal)
    {
    NodeQueue p;
    p=buildPath(open,closed,p,goal);
    Path path;
    path.cost=0;
    int size=p.size();
    path.path=new Node[size];
    for (int x=size-1;x>=0;x--)
    {
    path.path[size-1-x]=p[x];
    path.cost+=p[x].cost;
    }
    path.length=size;
    return path;
    }
    NodeQueue AStar::buildPath(NodeQueue open, NodeQueue closed, NodeQueue p, Node goal)
    {
    p.push_back(goal);
    Node n;
    n.coord=goal.parentCoord;
    if (doesContain(open,n)!=-1)
    {
    n=open[doesContain(open,n)];
    p=buildPath( open, closed, p, n );
    }
    else if (doesContain(closed,n)!=-1)
    {
    n=closed[doesContain(closed,n)];
    p=buildPath( open, closed, p, n );
    }
    return p;
    }

    /////////////////////////////////////////A többit inkább nem helyezem ki ,mert akkor inkább öngyilkosok lennétek mint ,hogy végigolvassátok az egészet
    ///////////////////////////////////////
    Jó szórakozást.

    Üdvözlettel:Tőlem!

    u.i.:Ja és ha végigolvastátok ,akkor adom a következő feladatot.

    1.Látogassatok el ide:www.happytreefriends.com .
    2.Nézzétek meg az összes filmet.
    3.Érezzétek jól magatokat!

    Majd jövök!

    Mutasd a teljes hozzászólást!

  • char ch[]; // Marhasag!!!!
    ch = "kutya"; // Marhasag!!!!


    az elso sor onmagaban nem marhasag

    a megoldas:
    a programod tobb forditasi egysegbol all (gyk. obj )
    es igy vezeted be a ch-t a meret ismerete nelkul, valamint C++ (es nem C) igy tombkent tortenik
    (bar hasznalhato a char* ch is helyette), ezzel jelzed, hogy te tombkent akarod ertelmezni, hasznalni

    ugyanis ha igy vezeted be:
    char* cc;

    akkor ez ok:
    cc += 1;
    de ch-ra:
    ch += 1;
    mar nem jo

    szoval azert...
    es egyeb pointerrel kapcsolatos muveletek eseten is...
    Mutasd a teljes hozzászólást!
  • Kösz a megnyugtatást!
    Mutasd a teljes hozzászólást!
  • Csak két baj van vele:
    1. az első sor végére nem kell a pontosvessző
    2. a "while" sorában a q elé is kell a *
    (legalább próbáld meg lefordítani mielőtt becopyzod)
    Amúgy működött.
    Toma
    Mutasd a teljes hozzászólást!
  • /*-----------------------------------------------------------------------* * filename - strcpy.cas * * function(s) * strcpy - copy string src to string dest *-----------------------------------------------------------------------*/ /* * C/C++ Run Time Library - Version 5.0 * * Copyright (c) 1987, 1992 by Borland International * All Rights Reserved. * */ #pragma inline #include <asmrules.h> #include <string.h> /*-----------------------------------------------------------------------* Name strcpy - copy string src to string dest Usage char *strcpy (char *dest, const char *src); Prototype in string.h Description Copy the ASCIIZ string *src to the buffer *dest. It is the callers responsibility to ensure that the dest buffer is large enough to contain the string, and to guard against supplying NULL arguments. Return value strcpy returns dest. *------------------------------------------------------------------------*/ #undef strcpy /* not an intrinsic */ #if defined(__FARFUNCS__) #include <_farfunc.h> #endif char *_CType _FARFUNC strcpy(char *dest, const char *src) { #if !(LDATA) _ES = _DS; #endif asm cld asm LES_ di, src asm mov si, di asm xor al, al asm mov cx, -1 asm repne scasb asm not cx #if (LDATA) #if !defined(__HUGE__) asm push DS #endif _DS = _ES; #endif asm LES_ di, dest asm rep movsb #if defined(__LARGE__) || defined(__COMPACT__) asm pop DS #endif return(dest) ; }
    Mutasd a teljes hozzászólást!
  • Esetleg egy példa:


    char *pstrcpy(char *p,const char *q);
    {
    char *s =p;
    while (*p++ =q++);
    return s;
    }

    Várj tudom előre a válaszodat!

    mrzool:
    Hát Disane igen-igen ,de ez sem jó.
    Mi lenne ha ezt próbálnád ki?

    ...........
    ...........
    ...........
    ...........

    Na ezt igy kéne.
    Mutasd a teljes hozzászólást!
  • 1.Miféle tanár?
    2.C++ zseni?
    3.ebben elképzelhető ,hogy igazad van.De akkor is véded magad.
    4.Értek is:
    Parancsolj.
    Mutasd a teljes hozzászólást!
  • Ha te tudod hogyan kell implementálni mutazsd be kérlek(hátha tanulunk belőle valamit)!


    1. Te vagy a tanár ebben a topikban.

    2. Te állítottad, hogy C++ zseni vagy.

    3. Tőled kérte nadamhu, nem pedig tőlem.

    4. Tényleg nem nehéz, egy olyan embernek, aki annyira ért hozzá, mint ahogy te magadról állítod, ez nem lehet probléma!
    Mutasd a teljes hozzászólást!
  • Sajnálom Bred látod az ilynek végett fel kell bontanom az egyezményünket.

    Kedves Mrzool!

    Ha te tudod hogyan kell implementálni mutazsd be kérlek(hátha tanulunk belőle valamit)!
    Mutasd a teljes hozzászólást!
  • char *strcpy (char *dirstr ,const char *sourstr);


    Ez az implementációja? Na ne már...
    Mutasd a teljes hozzászólást!
  • strcpy?
    Hmmm...

    A teljes neve nem véletlenül string copy?

    És valahogy igy néz ki:
    char *strcpy (char *dirstr ,const char *sourstr);
    Mutasd a teljes hozzászólást!
  • Disane2:
    Sajnos latszik, hogy nem teljesen erted a tombok fogalmat, ezert segitek egy kicsit. (A leiras biztos nem lesz teljesen szakszeru, de nem is vallakoznek tutorialok irasara. Es mindenkeppen olvass el egy C, majd C++ konyvet reszletesen.):

    Eloszor is tudd hogy ha van egy tombod, pl:

    char ch[7];

    akkor az a kifejezes, hogy 'ch', hasznalhato pointerkent is (char*)-kent, ami pont a tomb elejere mutat.

    Tehat nezzunk peldakat, es hogy mi tortenik:

    char ch[7];

    Deklaraltunk 7 karakter meretu tombot a memoriaban. Ekkor a program lefoglal 7 karakternyi teruletet, es ennek az elejere allitja a 'ch' mutatot.
    Az elozo pelda a tomb deklaralas inicializalas nelkul.

    Deklaralhatunk tombot ugy is, hogy nem adjuk meg a meretet, de egybol inicializaljuk, ezert a meretet a fordito kiszamoja:

    char ch[] = "kutya";

    Ekkor a fordito kiszamolja, hogy a "kutya" string 6 karakter hosszu. Lefoglal 6 karakternyi teruletet a memoriaban (ez praktikusan 6 byte), beleirja a "kutya" stringet, es az elejere allitja a 'ch' mutatot.

    A MOST KOVETKEZO PELDAK SZIGORUAN MARHASAGOK, AZOK A KEZDO PROGRAMOZOK VETIK OKET, AKIK AZ ELOZOEKET (SEM) ERTIK:

    char ch[]; // Marhasag!!!!
    ch = "kutya"; // Marhasag!!!!

    Mit tanultunk? Deklaralhatunk tombot a merete megadasaval, es inicializalassal: a lenyeg, hogy a fordito tudja a lefoglalando meretet. Mi itt azonban nem ezt tettuk, ezert mar az elso sor is baromsag. Tovabb ne is folytassuk.

    Kicsit advancedebb kezdo kodja:

    char ch[8];
    ch = "kutya"; // Ez igy marhasag!

    Mit csinalt a delikvens? Lefoglalt szepen egy 8 karakteres teruletet a memoriaban, majd a 'ch'-t az elejere allitotta. Erre a kovetkezo sorban a 'ch' mutatot raallitja a kodszegmensben levo "kutya" sztringre. A ch ugyan ertelmes stringre mutathatna igy, de akkor minek foglaltunk neki egy masik teruletet? Mas kerdes, hogy ez igy leglabbis C++-ban le sem fordul...

    Ha az elore lefoglalt teruletre akarsz kesobb stringet rakni, akkor azt igy teheted:

    char ch[8];
    strcpy(ch, "kutya");

    Ekkor a kodszegmensben levo memoriateruleten levo "kutya" striget bemasoljuk a 'ch' tommbbe.

    Disane2: Ismerted az strcpy fuggvenyt? Feladat: te hogyan implementalnad? Ird meg az strcpy fuggvenyt. Igazan nem bonyolult.
    Mutasd a teljes hozzászólást!
  • Bred:

    Kösz a tanácsot!Igazából most nem tudom mire gondolsz.Ha lehetne leirnád te ,hogy mire gondoltál?
    Mutasd a teljes hozzászólást!
  • sajnos kitetelemnek nem felel meg
    ugyanis
    csak ez legyen:
    char ch[];

    es ne ez
    char ch[] = "alma a fa alatt";

    amit irtal nem hulyeseg, de a fentebbi-re szeretnem a peldat, ha mar leirtad 2x is
    tehat a forraskodban csak a char ch[]; legyen, es magyarazd el, hogy ez igy magaban mire jo
    vagy ha nem tudod, akkor ne ird le az oktatoanyagodban, es a kovetkezoekben se alkalmazz olyan kifejezeseket amiket nem ismersz pontosan
    Mutasd a teljes hozzászólást!
Tetszett amit olvastál? Szeretnél a jövőben is értesülni a hasonló érdekességekről?
abcd