Lenne egy C++ házim holnapra, amit úgy néz ki nem igazán tudok megcsinálni. Elvileg egyszerű feladat lenne, csak nem értek C++-hoz. Van egy minta is, ami alapján meg lehet csinálni, illetve fel lehet használni. Ha valaki tudna segíteni, küldhetne egy mailt.

Természetesen nem ingyen kérem, mivel elég fontos lenne hogy meglegyen.

Ide írjon akit érdekel, és küldöm a mintát és a feladatot is:
virtual(kukac)pro(pont)hu

Up?
Most betegre keresheted magad, itt a nagy alkalom.

Lehet, hogy itt is lesz jelentkező, de szerintem jobban jársz, ha a prog.hu-n keresel embert, aki megírja neked: [link].
Ott tuti lesz jelentkező, ha fizetsz érte.

[Szerkesztve]

while (state(Korso) != _BROKEN) go(Korso, &Kut);

Megoldódott a dolog elég gyorsan, és ezúton is köszi akik írtak. Most már elmondhatom, hogy nem csak játékra, hanem tanuláshoz is használom a netet.

Sziasztok!
Kezdo kerdes, mivelhogy en is kezdo vagyok c, c++-ban:
Hogy viszel ki egy megvaltoztatott string parametert egy fuggvenybol?
Es itt a kerdesem: hogy viszed ki a fuggvenybol a string valtozot, vagy az erteket ?--sehol nem talaltam eddig erre doksikat...


Vagy itt egy kodszelet: hol a baja?

char *megfordit(char *szoveg)
{ unsigned int i=0,hossz=0;
char *forditva;
while(szoveg[hossz] != '\0') {hossz++;};//megnezem a hosszat

while(szoveg!='\0'){forditva=szoveg[hossz-1-i];++i;};
forditva='\0';

return forditva;
}

DevC++ utolso betaja kidob a progibol az ertekatadas kozben(Hozzaferesi megsertes--Segmentation Fault )

[Szerkesztve]

Tévedni emberi dolog. A számítógépek csak felgyorsíitják a folyamatot...

A forditott szövegnek nem foglalsz helyet. Ezt c-ben neked kell. És persze fel is kell szabadítani, ha már nincs rá szükség:

forditva = (char*)malloc(hossz + 1); /* a lezáró nulla bytenak is kell hely */

Egyébként egy string hosszát az strlen() függvénnyel le lehet kérdezni.

VladimirR: Köszi a bányászást, így már mindjárt más.
MOD: Ugyanakkor a dõlt betû megint továbbterjed a következõ hozzászólásra. Azt hittem ez már javítva

Jester

szerintem meg a forditva az egy ures pointer lesz es aze seg fault.

memoriat kene neki foglalni vagy inkabb helyben megforditani

Koszi, Miracle....de ez megint seg fault....
nem akarja kivinni azt a stringet...sehogy sem. fordito bug lenne?...kezdek begolyozni. 30 orat toltottem el vele, kiprobalva minden(ertek es cim szerinti) atadasi megoldast,remelem jol...nem tud vki linket adni egy okes doksihoz, ami ezt (is) targyalja?

[Szerkesztve]

Tévedni emberi dolog. A számítógépek csak felgyorsíitják a folyamatot...

Esetleg ha az egész programot megmutadnád. Jellemzõen ilyenkor máshol van a hiba
Ha az eredeti kódodba beszúrod a malloc-ot amit én írtam, akkor sem jó?

Mellesleg Miracle kódjával vigyázni kell, mert bár úgy látszik mintha új stringet adna vissza, valójában helyben fordítja meg. Ezzel két baj van: az összes többi helyen, ahol eltároltad a stringre mutató pointert szintén megfordul, illetve nem adhatsz be neki konstans stringet. Ha tehát úgy próbáltad ki pl. hogy megfordit(''abcde'') akkor az bizony segfault, mert a konstans string az nem írható, kivéve, ha erre külön kéred a fordítót (de ne tedd):

-fwritable-strings
Store string constants in the writable data segment and don't uniquize them. This is for compatibility with old programs which assume they can write into string constants.
Writing into string constants is a very bad idea; ``constants'' should be constant.

Jester

c-ben tenyleg ENNYIRE gaz a sztringkezeles. gyakorlatilag nincs is..

az algoritmus amit miracle adott ''majdnem'' jo, csak az indexeles van elcseszve de az nem okoz szegmens hibat

helyesen:

char* megfordit(char *str)
{
    char temp;
    int p = 0;
    int l = strlen(str);
    while (l - p > l/2)
    {
        temp = str[p];
        str[p] = str[l-p-1];
        str[l-p-1] = temp;
        ++p;
    }
    return str;
}

ezt ha <pre>char* akarmi = ''akarmi'' </pre><p> -kent deklaralt ''stringre'' hivod, az nem tom pontosan melyik szegmensben lesz de mindenesetre jo esellyel olyan helyen ahol nem szabad felulirnod, igy szepen vedelmi hiba lesz.

ezt a fv-t csak malloc-al foglalt char*-okra szabad meghivni, de malloc + akarmi = ''dasds'' mar megint nem jo mert az a pointert allitja at.

hogy ertsd mennyire korulmenyes, ez pl mar mukodne:

int main(int argc, char *argv[])
{
    char* nyekk = (char*)malloc(6);
    nyekk[0]='n';
    nyekk[1]='y';
    nyekk[2]='e';
    nyekk[3]='k';
    nyekk[4]='k';
    nyekk[5]='/0';
    printf(nyekk);
    nyekk=megfordit(nyekk);
    printf(nyekk);
  return 0;
}

ha deklaralasnal megadott stringekre akarod hasznalni, akkor masolatot kell keszitened a stringrol es azt visszaadnod, szal lekerdezed a hosszat, malloc-olsz neki 1el tobbet es abba pakolod a megforditott stringet, meg a vegere /0-t is. ekkor figyelni kell, hogy a kozepso betut is masolja at. (ha paratlan hosszu a stringed)</p></p>

[Szerkesztve]

b+ aludnom kene.. van olyan is hogy strcpy en meg karakterenkent adom meg

Sõt, van strdup is
De ha már úgyis dinamikus foglalás van, akkor miért ne a megfordított string legyen dinamikus?

Jester

itt a kod. Lehet hogy a main-ben a hiba?

lassuk,tehat, ho a baj, nekem mar elszallt a maradek energiam is...

#include<string.h>
#include <stdio.h>
#include <conio.h>
#include <malloc.h>

char* megfordit(char *str)
{
int hossz=0,i = 0;
char* forditva;
while( *str++ ) ++hossz;

forditva=(char*)malloc(hossz+1);
while(!(str))forditva=str[hossz-i++];
forditva='\0';
/*ha felszabaditom a forditva-nak lefoglalt helyet, akkor mi kerul a str-be? vagy automatikusan torlodik a fuggveny elhagyasakor?*/
return strcpy(str,forditva);
}

int main(void)
{char *sz,*szov;
printf(''kerem a szoveget...'');
scanf(''%s'',&sz);
printf(''a szoveg:...%s'',&sz);
printf(''forditva:...%s'',megfordit(sz));
getch();
return 0;
}


[Szerkesztve]

Tévedni emberi dolog. A számítógépek csak felgyorsíitják a folyamatot...

Mindjárt jobban látjuk a hibát.
Sajnos a bekért stringnek is kell hely és azt is neked kell lefoglalni.
Valamint a scanf és a printf hívásban nem &sz kell hanem simán sz.

Az ideiglenes stringet (forditva) az strcpy után felszabadíthatod, nem törlõdik automatikusan.

MOD: A printf nem tesz soremelést automatikusan, neked kell \n formában.

[Szerkesztve]

Jester

Igy gondoltad?

char* megfordit(char *str)

{
int hossz=0,i = 0;
char* forditva;
while( *str++ ) ++hossz;
printf(''Checkpoint'');getch(); //ezt figyeld!
forditva=(char*)malloc(hossz+1);
while(!(str))forditva=str[hossz-i++];
forditva='\0';
str=forditva;
free(forditva);
return strcpy(str,forditva);

}
int main(void)
{char *sz,*szov; int i=0;

printf(''kerem a szoveget...'');
scanf(''%s'',&sz);
printf(''a szoveg:...%s'',&sz);
szov=(char*)malloc(strlen(sz));
printf(''forditva:...%s'',megfordit(szov));
getch();
return 0;
}
Itt valami nem tiszta...de koszi a joindulatot, remelem sikerul elmagyaraznotok, hol mind hibazok....

Tévedni emberi dolog. A számítógépek csak felgyorsíitják a folyamatot...

Nem
Igy:

strcpy(str, forditva);
free(forditva);
return str;

A main-be pedig ilyesmit:

char sz[81];
...
scanf(''%80s'', sz);
printf(''a szoveg: %s\n'', sz);

MOD: az sz-t persze malloc-cal is foglalhatod, de mindenképp a scanf elõtt, mert az akar beleírni. A szov változóra nincs szükség.

Jester

koszi. Meg van egy kis hiba a forditva-ban, de azt megoldom. Fo az, hogy a segfaulttol megszabadultam, Koszi, sracok

Tévedni emberi dolog. A számítógépek csak felgyorsíitják a folyamatot...

mindenesetre ez igy nekem is serti a szeperzekem, helyben forgatashoz hasznaljunk void fvt es akkor egyertelmuen latszik, hogy az eredetit cseszi el a program, mert a tieddel meg csak annyit er el hogy lesz ket pointere ugyanarra a (megforditott) stringre, pedig c++-os gondolkodasmod alapjan marhara nem ezt varna.