- Redmi Watch 5 - formás, de egyszerű
- Samsung Galaxy S24 Ultra - ha működik, ne változtass!
- Google Pixel topik
- Apple Watch Sport - ez is csak egy okosóra
- Nem várt platformon a OnePlus Nord 5
- Samsung Galaxy Watch (Tizen és Wear OS) ingyenes számlapok, kupon kódok
- Megérkezett a Google Pixel 7 és 7 Pro
- Samsung Galaxy Watch6 Classic - tekerd!
- Garmin Instinct – küldetés teljesítve
- Google Pixel 9 Pro XL - hét szűk esztendő
Új hozzászólás Aktív témák
-
Lortech
addikt
A szóköz arra kellett, hogy ne fusson össze a két scanf, mivel benne maradt az előzőből a sorvége, és azt rakta bele a pontazon-ba, és egyből ugrott a következő scanf-re. Úgy vannak a fájlban az adatok, ahogy kiírod őket..
Nem teszteltem le, de ennek ránézésre mennie kéne, ha kiveszed a &-t a változók elől.
-
KMan
őstag
mostmar korrektul bekeri, de szeretnem kiiratni a bekert a elemeket. elvileg egymasutan jonnek a fajlban nem? ez a szokoz amit beltettunk nem zavart bele?
elvileg nem kene hogy szokozok legyenek a fajlban, minden adat egymas utan jon
pl igy nez ki a fajl: A1.24.3B4.53.2C12.3 stb...
ezzel probaltam meg kiiratni de semmi.
void pontokkiir()
{
i=0;
for (i=0;i<5;i++)
{
fprintf(fpontok, ''%c%lf%lf'', &spontok[ i ].pontazon,
&spontok[ i ].kelet, &spontok[ i ].eszak);
}
} -
#194
bpx
őstag
FehérHolló
#189
bpx
őstag
válasz
FehérHolló
#189
üzenetére
pascalban így működik az eof (előre ''jósol''), c-ben viszont nem :/
pont a másik programozós topikban is felmerült valamelyik nap a probléma
itt van egy lehetséges példa a megoldásra: [link] -
KMan
őstag
a 0. elemet meg korrektul bekeri, de az 1-nel mar kihagyja a pontazon scanf-jet es egyszerre dobja ki a printf-et.
#include <stdio.h>
#include <stdlib.h>
main()
{
typedef struct {
char pontazon;
double kelet;
double eszak;
}t_pont;
int i=0;
FILE * fpontok;
t_pont spontok[4];
fpontok=fopen(''C:\\PONTOK.DAT'',''wb'');
for (i=0;i<5;i++)
{
printf(''A(z) %d pontazon: \n'', i);
scanf(''%c'', &spontok[ i ].pontazon);
printf(''A(z) %d kelet: \n'', i);
scanf(''%f'', &spontok[ i ].kelet);
printf(''A(z) %d eszak: \n'', i);
scanf(''%f'', &spontok[ i ].eszak);
}
fclose(fpontok);
} -
#190
caddie
csendes tag
FehérHolló
#189
caddie
csendes tag
válasz
FehérHolló
#189
üzenetére
Sztem logikus, hogy az utobbi. Nem varhatjuk el C++-tol, hogy nekunk elore olvas (sott elvarjuk, hogy ne olvasgasson ossze vissza). A I/O flagek a stream aktualis allapotat tukrozik, amikor pedig a kov. elem az eof, akkor bizony az majd csak a kovetkezo olvasaskor fog kiderulni.
-
#189
FehérHolló
veterán
caddie
#178
FehérHolló
veterán
Nem tudom megnézni azóta sehol. Magamtól szerettem volna látni, mert úgy az igazi, de akkor most már inkább kérdezek.
Az eof flag akkor állítódik, amikor a beolvasott cucc után vége van a file-nak (de eof-et még nem olvasott be), vagy akkor, ha magát az eof-et olvasta be a file-ból?
A te mondandód alapján utóbbi az igaz, de én eddig az előbbit hittem. Most akkor mi a helyzet?
Remélem érted, amit kérdezni szeretnék.
[Szerkesztve] -
KMan
őstag
Na
Azt szeretnem hogy nincs a fajlban semmi. A progi ugye megnyitja a meg nemletezo fajlt irasra. Aztan a standard inputrol egyesevel bekeri a struktura egyes tagjait, es ezt elmenti a fajlban. Majd miutan ennek a muveletnek vege, csak a biztonsag kedveert szeretnek vegigmenni a fajlon es kiiratni az elemeket, csak hogy minden tuti-e. -
Lortech
addikt
Már megint lemaradtak az indexek, használj [ i ]-t. (szóközök)
a scanf helyett nem fwrite-ot kellene hasznalni? Most nem foglalkozom azzal hogy kiiirassam a kepernyore, csak bele akarom irni a fajlba, ugyhogy a bill-rol kerem be az adatokat.
Mi tudjuk, hogy mit akarsz? scanf-fel feltöltöd a struktúrát, ha ezt ki is akarod írni akkor nyilván kell valamilyen fájlíró függvény is (pl fwrite, fprintf, puts), de nem egyik a másik helyett, hanem együtt.. Vagy kiírhatod a fájlba a semmit is. 
(vagy nem értem)
#186: Melyik a tömböd? A spontok. Akkor pedig a 2.
[Szerkesztve] -
KMan
őstag
#include <stdio.h>
#include <stdlib.h>
void main()
{
typedef struct {
char pontazon;
double kelet;
double eszak;
} t_pont;
FILE * fpontok;
t_pont spontok[4];
int i=0;
fpontok=fopen(''C:\\PONTOK.DAT'',''wb'');
for (i=0;i<4;i++)
{
printf(''A(z) %d pontazon: '', i);
scanf(''%c'', &spontok.pontazon);
printf(''A(z) %d kelet: '', i);
scanf(''%f'', &spontok.kelet);
printf(''A(z) %d eszak: '', i);
scanf(''%f'', &spontok.eszak);
}
fclose(fpontok);
}
a scanf helyett nem fwrite-ot kellene hasznalni? Most nem foglalkozom azzal hogy kiiirassam a kepernyore, csak bele akarom irni a fajlba, ugyhogy a bill-rol kerem be az adatokat.
[Szerkesztve] -
Lortech
addikt
Mondjuk úgy az egész egy merő hiba..Printf > printf, Scanf > scanf, flose > fclose. Beolvasásnál nem kéne indexelni a spontok-at?
printf(spontok); -- printf nem találja ki, hogy mit akarsz, csak char-t adhatsz neki. Le kell programozni egy eljárást, amiben minden mezőjét kiiratod külön-külön egy t_pont-nak. -
KMan
őstag
Hello, itt mi a hiba? Koszi es udv
#include <stdio.h>
#include <stdlib.h>
void main()
{
typedef struct {
char pontazon;
double kelet;
double eszak;
} t_pont;
FILE * fpontok;
t_pont spontok[4];
int i;
fpontok=fopen(''PONTOK.DAT'',''wb'');
for (i=0;i<4;i++)
{
Printf(''A(z) %d pontazon: '', i); Scanf(''%c'', &spontok.pontazon);
Printf(''A(z) %d kelet: '', i); Scanf(''%f'', &spontok.kelet);
Printf(''A(z) %d eszak: '', i); Scanf(''%f'', &spontok.eszak);
}
for (i=0;i<4;i++)
{
Printf(spontok);
}
flose(fpontok);
} -
#179
FehérHolló
veterán
caddie
#178
FehérHolló
veterán
Így már értem, hogy mit szeretnél kifejezni, köszi!
Nincs semmiféle rekurzió.
String egy saját stringosztály, aminek a megírása egy másik házi volt. Kiegészítettem néhány dologgal, ami kellett ehhez a feladathoz. Lényegében ugyanazt csinálja, mint a beépített string osztály (konverzió tekintetében is), de ennek tudom a pontos felépítését, így inkább ezt használtam fel újra.
[Szerkesztve] -
#178
caddie
csendes tag
FehérHolló
#177
caddie
csendes tag
válasz
FehérHolló
#177
üzenetére
Ha megnezted volna amit irtam, akkor latszik, hogy en egy konkret eseten irtam le az algoritmus mukodeset, nem altalanossagban...
Olvasol egy sor adatot (n db olvasas egy ciklusban), pont EOF elott er veget az olvasasi sorozat. Az ellenorzes ebben az esetben termesztesen azt mondja, hogy meg nincs EOF, igy elkezded a kovetkezo (n db) olvasast: Az elso adat olvasasakor EOF jon, de te sehol nem ellenorzod, hanem haladsz szepen tovabb es beolvasol n-1 db tovabbi 'adatot' es amikor megtetted csak akkor ellenorzol EOF-ot ujra.
Tovabbra sem ertem ugyanakkor, hogy mi a terminalo feltetele a String::restore() rekurziv hivassorozatnak. A restore ismet es ismet meghivja onmagat...
Azt sem ertem, hogy miert nevezted el a String osztalyodat Stringnek? A standard ugyanis definial egy std::string -et, rendkivul megteveszto!! -
#177
FehérHolló
veterán
caddie
#176
FehérHolló
veterán
Szerintem meg úgy van, hogy:
1. file megnyit
3. megnyitás ellenőriz
2. eof ellenőriz
3. olvas
4. eof ellenőriz
5. olvas
...
Az a String::restore(ifstream&) hívása. De a restore-okkal nincs gond, mert ha többet kell restore-olni egymás után, akkor nem kerül egyikbe sem hülyeség. Csak mint mondtam, a végén ráolvas mégegyszer, amikor már EOF volt.
[Szerkesztve] -
#176
caddie
csendes tag
FehérHolló
#175
caddie
csendes tag
válasz
FehérHolló
#175
üzenetére
Nyilvanvaloan ciklus kesesben van az EOF ellenorzes, mert te a kovetkezot csinalod:
file: < megnyit
adat < ellenoriz majd olvas
adat < ellenoriz majd olvas
EOF < ellenoriz (adatot olvasott elozoleg) majd olvas(EOFot meg minden mast ami mar nincs is)
... < ellenoriz (EOF volt!) es kilep
Mas:
tmpstr.restore(f);
A restore fuggvenyen belul mi ez a masik restore hivas. Valami rekurziv fuggvenyhivas?
[Szerkesztve] -
#175
FehérHolló
veterán
FehérHolló
veterán
Már igazából tök mindegy, mert elfogadták a házit, csak engem piszkál a dolog:
Adott ez a kódrészlet, biztos, hogy ebben van a hiba:
ifstream if2(costfile,ios::binary | ios::in);
if(if2){
while(!if2.eof()){
tmpc.restore(if2);
C.insert(C.size(),tmpc);
}
if2.close();
}
Ez eggyel többször olvas be, mint kellene. Tehát EOF után még beolvassa a semmit, és nem nagyon értem, hogy miért. Biztos tök egyszerű a válasz, csak én vagyok a buta.
a restore(ifstream&) tagfüggvény így néz ki:
void restore(ifstream& f){
String tmpstr;
f.read((char*) &costumer_id,sizeof(unsigned));
tmpstr.restore(f);
f.read((char*) &to_pay,sizeof(unsigned));
f.read((char*) &paid,sizeof(unsigned));
f.read((char*) &item_out,sizeof(unsigned));
this->set_name(tmpstr);
}
[Szerkesztve] -
#174
amargo
addikt
FehérHolló
#173
amargo
addikt
válasz
FehérHolló
#173
üzenetére
Szerk: Hülyeséget keztem leírni, az előbb.
[Szerkesztve] -
#173
FehérHolló
veterán
satchmo
#172
-
#171
amargo
addikt
FehérHolló
#167
amargo
addikt
válasz
FehérHolló
#167
üzenetére
-
#169
Jester01
veterán
FehérHolló
#167
Jester01
veterán
válasz
FehérHolló
#167
üzenetére
Szerintem várd meg míg Amargo megmagyarázza, mert nekem sem tiszta mi előnye van a 2 time hívással szemben. Ráadásul ezek windowsos varázslatnak tűnnek.
-
#167
FehérHolló
veterán
amargo
#165
FehérHolló
veterán
Erről rögtön levágta volna a gyakvezér, hogy nem én csináltam.
Két sima time()-al megoldottam a problémát.
Köszi szépen a segítséget! Ezt elrakom későbbre emésztgetni (2 órát aludtam, és most nem jön össze semmi...).
Csak eléggé rámijesztettek, amikor elkezdtek mellettem 300soros időkezelésről beszélgetni a többiek.
A union nem struktúra.
[Szerkesztve] -
#165
amargo
addikt
FehérHolló
#163
amargo
addikt
válasz
FehérHolló
#163
üzenetére
union { // Struktura
LONGLONG li;
FILETIME ft;
} CreateTime, EndTime, ElapsedTime;
SYSTEMTIME SYSstart, SYSend, SYSelapsed;
GetLocalTime(&SYSstart);
Sleep(600);
GetLocalTime(&SYSend);
SystemTimeToFileTime(&SYSstart, &CreateTime.ft);
SystemTimeToFileTime(&SYSend, &EndTime.ft);
ElapsedTime.li = EndTime.li - CreateTime.li;
FileTimeToSystemTime(&ElapsedTime.ft, &SYSelapsed);
Bár a dátumra nem tökéletes, de én uniont hazsnálnék a célra. -
#164
caddie
csendes tag
FehérHolló
#161
caddie
csendes tag
válasz
FehérHolló
#161
üzenetére
En megmondom oszinten nem ertem mi a kerdes. Kiprobalod aztan majd kiderul.
-
#162
Jester01
veterán
FehérHolló
#161
Jester01
veterán
válasz
FehérHolló
#161
üzenetére
Mire is kell itt a ctime?
-
#161
FehérHolló
veterán
FehérHolló
veterán
Itt is feltenném a kérdést.
Ennek a második bekezdésében van leírva: [link]
A kivételi és visszahozatali időt time()-al tárolnám, majd ctime()-al hasonlítanám őket.
[Szerkesztve] -
caddie
csendes tag
válasz
norbiphu
#159
üzenetére
A kodot nem neztem, de a copy konstruktor azert hivodik, mert az operator*() egy temporalis objektumot 'hoz letre' es ez adodik ertekul a b-nek.
# 1 b = b * 2
# 2 b = [ c ]
# 3 b = c
Ez lenne a normalis megvalositasa egy opeartor*() -nak, amely 'free' esetleg friend fuggvenykent van megvalositva.
[Szerkesztve] -
norbiphu
őstag
üdv!
adott ez a kód [link]
azt nem értem, hogy b = b *2 - nél, meg b = 3 * b miért hívodik meg a copy konstruktor
.
addig oké, hogy operator* miatt kiirja az szorzót, utána pedig operator= - höz ugrik.
ott viszont elvesztettem a fonalat, hogy miért ez a sorrend.
köszi a segítséget
-
Pitasama
csendes tag
Sziasztok!!!
Bocs a késői jövetelért, de már annak is örülök, h idetaláltam...
Szóval... Eléggé nagy gázban vagyok.... egy feladatot kéne megcsinálnom, de fingom nincs hozzá nem is értem... :S
Szóval ha esetleg meg tudnátok csinálni nagyon megköszönném!
Készítsen el egy osztályt (zeneszám) zeneszámok tárolására!
Legyen egy max. 40 ch hosszú attribútuma az előadó, egy max 40 ch hosszú attribútuma
a zene címének, továbbá egy egész változója a szám hosszának másodpercekben történő
tárolására. Lássa el az osztályt a zegyes változók bállítására, ill. kiíratására
szolgáló metódusokkal! (setArtist, getArtist, setTitle, getTitle, setLength, getLength)
Ebből az osztályból hozzon létre 3 objektumot és alkalmazza rájuk a megírt metódusokat!
Ez lenne az. Kérlek titeket, h ha vki tudja a megoldást, hétfő este 8-ig próbálja vhogy hozzám eljuttatni... és lehetőleg úgy, h az objektumos részt zárójellel a szöveg mögött elmagyarázva, h mi miért van.
Előre is köszönöm!!!!
jah és lehetőleg erre a mélre küldjétek el nekem mert nem fix, h elérem az oldalt a kóterból.
Köszi
jóccakát mkinek!!! -
Zulfaim
csendes tag
Befejeztem.
Ez lett a vége:
#include <cstring>
#include <iostream>
#include <fstream>
using namespace std;
class buffer {
char* buff;
int size;
public:
buffer():buff(0),size(0){}
buffer(const buffer&);
buffer& operator=(const buffer&);
buffer& operator+=(const buffer&);
bool operator==(const buffer&);
buffer& buffer:: operator+=( const char*);
buffer& buffer:: operator=(const char*);
bool buffer:: operator==(const char*);
friend void beolvas(buffer &);
friend void kiir(buffer &);
friend ostream& operator<<(ostream& s, const buffer b);
friend istream& operator>>(istream& s, const buffer b);
~buffer(){ delete[] buff; }
};
buffer::buffer(const buffer& e)
{
buff=new char[(size=e.size)+1];
if (e.buff)
strcpy(buff,e.buff);
}
buffer& buffer:: operator+=( const char* value)
{
char* temp=new char[size = strlen(buff)+ strlen(value) +1];
strcpy(temp,buff);
strcat(temp, value);
delete[] buff;
buff = temp;
return *this;
}
buffer& buffer:: operator+=(const buffer& e)
{
char* temp=new char[size+=(e.size+1)];
strcpy(temp,buff);
strcat(temp,e.buff);
delete[] buff;
buff=temp;
return *this;
}
buffer& buffer:: operator=(const char* value)
{
delete[] buff;
if( size=strlen(value))
{
buff=new char[size+1];
strcpy(buff,value);
}
return *this;
}
buffer& buffer:: operator=(const buffer& e)
{
if( this!= &e)
{
delete[] buff;
buff=new char[size=e.size];
strcpy(buff,e.buff);
}
return *this;
}
bool buffer:: operator==(const char* value)
{
if(size==strlen(value)) return true;
else return false;
}
bool buffer:: operator==(const buffer& e)
{
if(size==e.size) return true;
else return false;
}
ostream& operator<<(ostream& s, const buffer b)
{
for(int i=0;i<b.size;++i)
{
s<<b.buff;
}
return (s);
}
int karakterek_szama()
{
fstream fp(''c:\\txt.txt'',ios::in);
char c;
int k=0;
while(!fp.eof())
{
fp.get(c);
++k;
}
fp.close();
return k;
}
istream& operator>>(istream& s, buffer b)
{
int k=karakterek_szama();
delete[] b.buff;
b.buff=new char[(b.size=k)+1];
for(int i=0;i<b.size;++i)
{
s>>b.buff;
}
return (s);
}
void beolvas(buffer& b)
{
int k=karakterek_szama();
delete[] b.buff;
b.buff=new char[(b.size=k)+1];
fstream fp(''c:\\txt.txt'',ios::in);
while(!fp.eof())
{
fp.getline(b.buff,b.size);
}
fp.close();
}
void kiir(buffer& b)
{
fstream fp(''c:\\txt.txt'',ios:
ut);
fp<<b.buff;
fp.close();
}
int main()
{
buffer b;
buffer a;
beolvas(b);
char s[7]=''+FUZES'';
char s2[11]=''ASDFWERGWE'';
a=s2;
cout<<(a==b);
cout<<endl;
b+=s;
cout<<b;
cout<<endl;
b+=a;
cout<<b;
kiir(b);
cin.get();
return 0;
}
[Szerkesztve] -
Zulfaim
csendes tag
Most a program beolvasás részét próbálom megoldani, de valami probléma van vele.
int karakterek_szama()
{
fstream fp(''c:\\txt.txt'',ios::in);
char s[100];
int k=0;
while(fp>>s)
++k;
fp.close();
return k;
}
istream& operator>>(istream& s, buffer b)
{
int k=karakterek_szama();
delete[] b.buff;
b.buff=new char[(b.size=k)+1];
for(int i=0;i<b.size;++i)
{
s>>b.buff;
}
return (s);
}
void beolvas(buffer b)
{
fstream fp(''c:\\txt.txt'',ios::in);
while(fp>>b.buff)
fp.close();
}
A karakterek_szama() fgv.-el meghatározom, hogy mennyi memóriaterület kell.
Ezt lefoglalom és kiolvasom a fájl tartalmát.
A beolvas függvény friend.
Nem működik.
[Szerkesztve] -
caddie
csendes tag
1, Osztalyon kivul definicio:
- letisztult marad az osztaly interface ( kod olvashatosag )
- tipikusan kulon header / forras fileokba rendezzuk az osztaly deklaraciot es definiciot, hogy az osztaly implementaciojanak megvaltoztatasakor ne kelljen ujraforditani mindne olyan forrasfilet, amely csak az interface-tol fugg (erre vannak meg szofisztikaltabb modellek is pl: pimpl idiom)
- C++ -ban az a szokas, hogy az inline fuggvenyeket definialjuk osztalyon belul, amelyek 1-2 sorosak, a tobbit pdig osztalyon kivul definialjuk
2, using namespace std;
- ezt alapbol nem ajanlott hasznalni, mert az std nevterben levo osszes elerheto nevet beemeli, helyette specifikusan a hasznalt neveket szokas / vagy meginkabb minositeni szokas a hasznalt dolgokat
- ha header file-ba irod be, akkor az osszes forrasfile amely felhasznalja a headert keretlenul is megkapja az osszes std nevterben levo elerheto nevet
- nevtereket pont azert talaltak ki, hogy particionalva legyenek (felosztva) a nevek. using namspace std beemelesevel pont ezt iktatjuk ki, hiszen minden beemelunk a ''globalis'' nevterbe
3, inicializalasi lista:
- amikor a konstruktor torzsebe adod meg, hogy adott member valtozonak milyen kezdoerteket szeretnel megadni, akkor eloszor letrejon az objektum, lefut a default konstruktora, majd egy kulon fuggvenyhivas kereteben masolodik at a kezdoertek. inicializalasi listaval az adott valtozo konstrualasakor mar kezdoertekkel latod el azt (tehat hatekonyabb es igy az elegans, erre talaltak ki az inicializalasi listat).
4, size_t: STL az egy peldas kod, erdemes annak a filozofiaja szerint dolgozni, annak eszkozeit hasznalni es amennyire ertelmes idomulni hozza.
5. NULL nincs benne a C++ szabvanyban, teljesen forditofuggo, hogy van-e benne, mi van mogotte (makro) es hogy a fordito kov. verziojaban is benne lesz-e. amugya 0 -nak implicit konverzioja van pointerekre.
6. a postfix novelo operatorok definicio szerint egy temporalis objektumba mentik a valtozo eredeti erteket, majd megnovelik a valtozo erteket, a regi erteket pedig visszadjak. a prefix novelo operator cask novel es visszaad, ergo a postfix min 2x annyi muveletet vegez (szamszeruleg, valoszinuleg a fordito ugyanis kioptimalizalja). A lenyeg, hogy prefix kell mindenhova kiveve ahova postfix kell
Roviden ennyi, remelem nem hagytam ki semmit -
caddie
csendes tag
Hat a kod sok-sok sebbol verzik:
- buff = ' 'zzz' ' ez mi ez?, miert nem hasznalsz inicializalasi listat?
- kiiro operatornak nyugodtan lehet const buffer& -t atadni
- += operatornt - minimalisan - igy modositanam:
)
buffer& buffer:: operator+=( const char* value)
{
char* temp=new char[size = strlen(buff)+ strlen(value) +1];
strcpy(temp,buff);
strcat( temp, value);
delete[] buff;
buff = temp;
return *this;
}
teljesen feleslegesen masolgatsz es foglalsz memoriat. Jelen pillanatban nem ellenerozom, hogy az atadott pointer null pointer / van legalabb 1 karkater benne stb. Ezt belehekkelheted.
- ertekado operatornal, bevallom nem ertem ezt:
for(int i=0;i<size;i++)
{
buff=e.buff;
}
ez mi ez?
talan
for(int i=0;i<size;i++)
{
buff [ .i. ] =e.buff [ .i. ] ; // konvertalas miatt :(
}
? De ez sem jo, mert a vegere nem masolja oda a '/0' -t. Sztem erdemesebb lenne hasznalni a strcpy-t
- kiiro operator hasonloan beteg
- nem latok racionalis okot, hogy meirt van a += es az egyik ertakado operator az osztalyon belul definialva, a tobbi meg kivul.
- copy konstruktor is beteg, keves memoriat foglalsz es utana u.a. a hulyeseg van mint ertakado operatornal
- sztem teljsen feleslegesen a postfix incerementalo operatorok
[Szerkesztve] -
-
Zulfaim
csendes tag
nem tudom hova feltölteni.
#include <cstring>
#include <iostream>
using namespace std;
class buffer {
char* buff;
int size;
public:
buffer(){buff=''ZZZ''; size=3;}
buffer(const buffer&);
buffer& operator=(const buffer&);
friend ostream& operator<<(ostream& s, const buffer b);
~buffer(){ delete[] buff; }
buffer& buffer:: operator+=( const char* value)
{
char* temp=new char[strlen(buff)+1];
strcpy(temp,buff);
if(size+=strlen(value))
{
delete[] buff;
buff=new char[size+1];
strcpy(buff,temp);
strcpy(buff+strlen(value),value);
}
delete[] temp;
return *this;
}
buffer& buffer:: operator=(const char* value)
{
delete[] buff;
if( size=strlen(value))
{
buff=new char[size+1];
strcpy(buff,value);
}
cout<<''__az '=' this-je__''<<*this;
return *this;
}
};
buffer::buffer(const buffer& e)
{
buff=new char[size=e.size];
for(int i;i<size;i++)
{
buff=e.buff;
}
}
buffer& buffer:: operator=(const buffer& e)
{
if( this!= &e)
{
delete[] buff;
buff=new char[size=e.size];
for(int i=0;i<size;i++)
{
buff=e.buff;
}
}
return *this;
}
ostream& operator<<(ostream& s, const buffer b)
{
for(int i=0;i<b.size;i++)
{
s<<b.buff;
}
return (s);
}
int main()
{
char s[7]=''BUFFER'';
buffer b;
cout<<b;
b=s;
cout<<b;
cout<<endl;
b+=s;
cout<<b;
cin.get();
return 0;
}
most az a baj vele, hogy a this-be ilyen baromságokat rak( memóriaszemét), de nem tudom, hogy mitől kapja. Nem hiszem, hogy a konstruktor hibája lenne. -
Lortech
addikt
válasz
BaKeSZ87
#136
üzenetére
pl:
FILE *fp;
if ((fp = fopen(''c:\\valami.txt'', ''a'')))
puts(''szar'');
else
{
puts(''jo'');
char string[11];
puts(''Mit írjak ki? : '');
fgets(string,10,stdin); /*vagy gets(string); ha mindenáron gets, de akkor a char tömböt halálbiztos méretűre kell állítani, mert ír a tömb maxindex után is, ha kell ha nem..*/
if (fputs(string,fp) != EOF) puts (''siker'');
}
[Szerkesztve] -
Zulfaim
csendes tag
buffer& buffer:
perator+=( const char* value)
{
char* temp=new char[size+strlen(value)+1];
if(value)
{
strcpy(temp,buff);
strcpy(temp + strlen(buff), value);
delete[] buff;
buff = temp;
}
return *this;
}
int main()
{
char s[7]=''BUFFER'';
buffer b;
b=s;
cout<<b;
b+=s;
cout<<b;
cin.get();
return 0;
}
nem működik rendesen. -
Zulfaim
csendes tag
class buffer {
char* buff;
int size;
public:
//buffer() : buff(0), size(0){}
buffer(int s=10){buff=new char[size=s];}
buffer(const buffer&);
buffer& operator=(const buffer&);
friend ostream& operator<<(ostream& s, const buffer b);
~buffer(){ delete[] buff; }
buffer& buffer:perator=(const char* value)
{
delete[] buff;
if( size=strlen(value))
{
buff=new char[size+1];
strncpy(buff,value,size);
}
return *this;
}
};
buffer::buffer(const buffer& e)
{
buff=new char[size=e.size];
for(int i;i<size;i++)
{
buff=e.buff;
}
}
buffer& buffer:perator=(const buffer& e)
{
if( this!= &e)
{
delete[] buff;
buff=new char[size=e.size];
for(int i=0;i<size;i++)
{
buff=e.buff;
}
}
return *this;
}
ostream& operator<<(ostream& s, const buffer b)
{
for(int i=0;i<b.size;i++)
{
s << b.buff;
}
return(s);
}
int main()
{
buffer b;
b=''xyz'';
b+=''-=EZ A BUFFERHEZ FUZOTT RESZ=-'';
cin.get();
return 0;
}
Ezzel mi a baj?
[Szerkesztve] -
caddie
csendes tag
Azt hiszem, hogy a problemak egy reszet mar leirtak, en meg javasolnek 1-2 dologt:
- nagyon nem illik a headerekbe a using namespace std;-t beleirni
- a standard konyvtar definial egy vector template osztalyt, majdnem azonos neven
- a kiiro operator definialasakor te igazabol egy free (''globalis'') fuggvenyt definialsz, amely egyik parametere template osztaly. ebbol kifolyolag az altalad definialt kiiro operatornak is templatenek kell lennie (alatta ki is van kommentezve)
- konstruktoroknal erdemes hasznalni az inicializalasi listat (ezzel kikerulheto a telejsen felesleges default konstrualas es az ezuatni ertekadas)
- unsigned int-ek helyett, erdemes hasznalni az STL-hoz hasonloan a size_t tipust
- ertekado operatorok tipikusan T& ternek vissza a lancbafuzes tamogatasa miatt, de persze lehet, neked pont az volt a celod, hogy ilyen dolgokat ne engedj meg
- mivel letezik a vektor meretenek lekerdezesere kialakitott interface (size()), ezert velemenyem szerint felesleges a kiiro template operatort friendkent deklaralni
- a NULL nem szabvanyos! nullat hasznalj helyette
- a copy konstruktort biztos igy akartad csinalni?
{
Vector<int> a;
// a-t feltoltod elemekkel
Vector<int>b(a);
}
// megsemmisul a, felszabadul a.pData;
// felszabadul(na) b.pData;
// de mivel a.pData == b.pData ami mar megsemmisult,
// ehelyett katasztrofa lesz
// alternativ eset
a.clear(); // felszabadul a.pData (b.pData is oda mutat)
b[5];
// szerencses esetben elcrachel a programod
// peches esetben pedig fut tovabb csak hulyeseg irodik ki
// megpechesebb esetben jo irodik ki
// klasszikus undefined behaviour
- copy konstruktor egyertelmuen hibas
- assert.h helyett majd inkabb cassert-et hasznald
- erase eseten, ha egy elemed volt akkor -1-re alitod az elemenNum-t
- postfix increment / decrementalas helyett erdemes a prefixet hasznalni (ahol persze azonos a ketto funkcionalitasa)
- erase eseteben a torlendo elem kihagyasa nem tul elengas, sott gyanus, hogy a for ciklusnal a ciklusfeltetel tulindexelest fog eredmenyezni
- insert-nel erdemes lenne const T& -et atadni
- ennek nem latom sok ertelmet:
if(elementNum==UINT_MAX)
{
return false;
}
de ha mar ilyenekre figyelsz, akkor erdemes lenne inkabb a C++ std altal biztositott dolgokat hasznalni, tovabba inkabb a new sikeres memoriafoglalasat ''leellenorizni''* (bar egy beadando eseteben egyiknek sincs tul sok jelentosege)
* erdemes eszrevenni, hogy alap esetben std::bad_alloc exceptiont dob, de nothrow-os valtozat hasznalataval ra lehet venni arra is, hogy nullpointert adjon vissza sikertelen foglalas eseten
- insertnel megint az kell, hogy modnjam, hogy ez nem tul elegans modja az elem beszuarasanak
- insertnel ha pos > mint az aktualis vektor merete, akkor ne egyenkent toltsd fel nullaval, hanem default konstruald nullaval inkabb
- insertnel nem latom pontosan, hogy miert pos + 1 meretu tombot foglalsz
- [] operator eseteben az az altalanos STLes megkozelites, hogy [] nem ellenoriz indexhatarokat, csak at teszi azt, igy az at fuggvenyt a [] segitsegevel valositjak meg.
- eddig sem lattam sok ertelmet az asserteknek, az amlitett dolgok nem olyan hibak amiert le kene shutdownolni az egesz programot, de ertekado operator eseteben egyenesen a jozan esz ellen megy. Abban az esetben inkabb egy return *this; kellene, amennyiben onertekadasrol lenne szo
Igy elso atfutasra en ezeket a furcsasagokat vettem eszre, nehany kozulok talan csak sznobizmus, de azert akadt kozottuk par tervezesi hiba es eletveszelyes undefined behaviour is.
[Szerkesztve] -
Jester01
veterán
Az a <class T> az olyan mint a függvényeknek (vagy makróknak) a paramétere. Tehát a T az tetszõleges név lehet. Az egész úgy mûködik, hogy a T helyére a példányosítás során adott osztályokat (típusokat) helyettesít be. A te kódodban Vector osztály nem létezik, az csak egy minta (template). Tehát igazából sehova sem írhatod azt, hogy Vector, mindenhol meg kell adnod a behelyettesítendõ típust vagy konkrétan vagy pedig template paraméterrel (ez alól azt hiszem vannak kivételek, de olyanról nem tudok, hogy ne lehetne kiírni -- vagyis az a biztos ha mindenhová kiírod).
Ezen felül csak annyi hiba volt a progiban, hogy hiányzott az assert.h és az operator<< visszatérési típusánál egy helyen lemaradt az & jel, valamint a friend deklarációnál is kell a template kulcsszó. -
ktg3
őstag
válasz
Jester01
#127
üzenetére
nekem összesen 2 db hibaüzit dob..
az a baja h nem működik meg annyira nem is értem h h működik ez a template..
elvileg le kéne h fusson ez a baja: D
mmint a tudásom szerint
mert ugyen aza akar lenni h a vector osztály tudjon megadott típussal működni..
szal azokat az inteket ( eredetileg inteket tárolt) írtam át tre ahol sztem kellett..
szal annyira konkrétan a szintaktikát sem tudom
annyit találtam róla ha a headeren belül implementálod a fgv-eket akkor mindegyik elé kell az a temlate <class T>... -
amargo
addikt
Hamár, a másikat így eltoltam.. ebben mi a hiba?
template <class Var>
void fgetNum(Var &n, Var lob, Var hib)
{
string str;
n = 0;
while(getline(cin, str))
{
bool error = false;
int dot = 0, i = 0;
if( str[ 0 ] == '-')
i = 1;
for( ; i < str.length(); ++i )
{
char ch = str[ i ];
if (IsDigit(str[ i ])) continue;
else if(str[ i ] == '.' && dot < 1)
{
dot++;
}
else
{
error = true;
}
}
if(!error)
{
n = (Var)atof(str.c_str());
}
if((n < lob || n >= hib) || error)
{
cout << ''Hibas a bevitt ertek\n'' << lob << '' -tol, '' << hib << '' -ig. Adja meg a szamot.'' << endl;
}
else
{break;}
}
}
atof-nél van valami jobb átalakító? mint borlandéknál az StrToInt? -
amargo
addikt
válasz
Jester01
#119
üzenetére
Hi!
Egyetértek. Bambán csak beszurtam a template-et.. hogy lebegőpontosra is jó legyen.. figyelmen kívűl hagyva dolgokat.. rengeteg részletet ki is hagytam, a figyelésből..
Viszont ez a istringstream egyből leveszi a válunkról a feladatot ezért hálás vagyok, hogy megmutattad!
Kicsit belekontárkodtam:
template <class Var>
void getNum(Var &n, Var lob, Var hib)
{
string str;
while(getline(cin, str))
{
istringstream tmp(str);
tmp >> n;
if (!tmp.fail() && tmp.eof() && n <= hib && n >= lob) break;
cerr << ''Invalid input'' << endl;
}
}
Belekötni nem tudok, mert minek is? -
Jester01
veterán
előnye, hogy lebegőpontos számokat is képes kezelni.. Nem kell hozzá átírkálni.
Biztos? Ha jól látom az atoi függvényt hívod, abból hogy jön majd ki lebegőpontos? Egyéb problémák:
* str[ 0 ] == '-' Ez a feltétel miért van a ciklusban? Sőt, miért van egyáltalán? Nem lehet negatív számot beadni?
* Ha egész szám bekérése esetén pl. 3.3-at adok be akkor szerintem nem ad hibát.
* Hibás számra (mondjuk amiben több pont van) szintén nem ad hibát.
* isdigit függvény van ám ''gyárilag'' (és a pont az bizony nem digit -- így félrevezető a függvény neve)
Az én verzióm soronként egy szám beolvasására a következő lenne:
template <class Var>
void getNum(Var &n, Var lob, Var hib)
{
while(!cin.eof())
{
string str;
getline(cin, str);
istringstream tmp(str);
tmp >> n;
if (!tmp.fail() && tmp.eof() && n <= hib && n >= lob) break;
cerr << ''Invalid input'' << endl;
}
}
Nyugodtan tessék belekötni ha van benne hiba. -
Ramius
őstag
A megoldásod nem lett 100%-os, de az alapján kijavítottam a kódomat erre:
for(a=0;a<5;a++)
{
printf(''\nKerem a(z) %d. tippet: '',a+1);
fflush(stdin);
scanf(''%d'',&tipp[a]);
if (tipp[a]<1 || tipp[a]>90)
{
printf (''\nHibas tipp, 1 es 90 kozott lehet csak a szam! Add meg ujra!\n'');
printf(''Kerem a(z) %d. tippet:'',a+1);
scanf(''%d'',&tipp[a]);
}
}
Köszönöm a segítséget
[Szerkesztve] -
amargo
addikt
A Scanf-el is meg lehet csinálni, csak én már untam, hoyg annyi mindent kell lekezelni sokszor.. Pointerekkel lehetne még igazán jól lekezelni a dolgot, hogy ne is legyen pazarló, de amilyen szinten a tanárok elvárják, ahhoz most ez is jó:
//---------------------------------------------------------------------
bool IsDigit(char ch)
{
return ((ch >= '0' && ch <= '9') || ch == '.');
}//bool IsDigit(char ch)
//---------------------------------------------------------------------
template <class Var>
void getNum(Var &n, Var lob, Var hib) //lob az alsó határ
{
bool error;
do
{
string str;
n = 0;
error = false;
cin >> str;
for(int h = 0; h < (signed)str.length(); h++)
{
if(!IsDigit(str[ h ]) || str[ 0 ] == '-' )
{
error = true;
cout << ''Hiba, Szamot adjon meg!\n'' << endl;
break;
}
}
if(!error)
{
n = (Var)atoi(str.c_str());
}
if((n < lob || n >= hib) || error) //Nem engedjük meg a hib-ig menni és a lob-nál nagyobbnak kell lennie!
{
cout << ''Hibas a bevitt ertek\n'' << lob << '' -tol, '' << hib << '' -ig. Adja meg a szamot.'' << endl;
error = true;
}
}while( !(lob <= n) || error);
}//int getNum()
Szerk: az előnye, hogy lebegőpontos számokat is képes kezelni.. Nem kell hozzá átírkálni.
[Szerkesztve] -
norbiphu
őstag
válasz
norbiphu
#107
üzenetére
KÉSZ!
operator= - ben is túlindexeltem a /0 - t, csak nem ott kerestem a hibát.
valamint a kivonásban úgy pakoltam a result int tömbből az eredményeket a visszaadandó tört stringbe, hogy nem is volt neki memória foglalva (ezt miért engedi a vs, miért nem warningolt?)
FehérHolló, -Zeratul- -
#110
bpx
őstag
FehérHolló
#108
bpx
őstag
válasz
FehérHolló
#108
üzenetére
az igaz, de null-ra akkor is be kell állítani
a destruktoros ellenőrzés inkább már ilyen bme-s mánia, hogy a legkisebb 3 soros példaprogramban is 6szor ellenőrzünk, hogy a későbbi bővítésnél ne legyen gond -
Zulfaim
csendes tag
Szevasztok!
Bufferelten kezelt fájlt kellene írnom c++-ban OO-an.
Csináltam egy buffer osztályt, ahol tárolok egy pointert és a méretet.
Ennek kéne működnie:
buffer+=szoveg;
ahol mindketten string-et tároló tömbök.
a szoveget is úgy tárolom, hogy pointer+méret, de azt a main()-ben hozom létre.
Ezt operátor overloaddal kéne megoldani, de nem tudom hogy.
Tudna valaki segíteni? -
#108
FehérHolló
veterán
bpx
#104
FehérHolló
veterán
Tudtommal ha nullpointerre hívod meg a delete-et vagy a delete[]-t, akkor nem csinál semmit. Rosszul gondolom ezek szerint? Órai anyagban, és netes forrásokban is mindenhol ezt írják, hogy nem csinál semmit. Sőt, a tapasztalat is ezt mutatja, amikor másolókonstruktorban felhasználom az operátor egyenlőt, és előtte törlöm, ami ott volt.
-
bpx
őstag
válasz
norbiphu
#102
üzenetére
#include <iostream>
class T{
char* t;
public:
T(char* z) {
t=new char[strlen(z)+1];
strcpy(t,z);
t[strlen(z)]='\0';
// tulcimezted a tombot, nem kell a +1, mert 0-tol indul a cimzes
}
~T() {
if (t!=NULL) delete[] t;
// destruktort eszedbe ne jusson enelkul megirni, kulonben ugy szall el, hogy csak na}
// ehhez persze param. nelkuli konstruktor is kell, ami beallitja NULL-ra akkor is, ha nem csinalsz semmit
};
int main() {
T A(''323232'');
}
[Szerkesztve] -
#103
FehérHolló
veterán
norbiphu
#102
FehérHolló
veterán
válasz
norbiphu
#102
üzenetére
Kicímzel a tömbből a '\0' berakásánál. A legnagyobb index strlen(z).
Másrészt ezzel egy nagyobb baj is van. Ha z alapból nem nullterminált, akkor nem működik rá a strlen() függvény. Ha pedig z nullterminált, akkor szükségtelen a t végére berakni egy '\0'-t.
A harmadik gond pedig a main()-en belül az A objektum inicializálásánál van. A () zárójelbe nem két ''-t (shift+1) kell rakni, hanem egy ''-t (shift+2). De ha így adod be neki a stringet, akkor zárd le '\0'-al, és nem lesz baja a konstruktornak sem. (A két első hibát kiküszöbölöd.)
Szerk: Jé, most látom, hogy két shift+1 egymás mellett ugyanúgy néz ki, mint a shift+2, ha code blokkba rakom.
[Szerkesztve] -
#102
norbiphu
őstag
FehérHolló
#101
norbiphu
őstag
válasz
FehérHolló
#101
üzenetére
#include <iostream>
class T{
char* t;
public:
T(char* z) {
t=new char[strlen(z)+1];
strcpy(t,z);
t[strlen(z)+1]='\0';
};
~T() {delete[] t;}
};
int main() {
T A(''323232'');
}
ez se fut le...
[Szerkesztve] -
#101
FehérHolló
veterán
norbiphu
#99
FehérHolló
veterán
Bocs, most látom, hogy közben szerkesztetted az előzőt.
A destruktor jó, valamit közben szúrtál el. A két legvalószínűbb dolog a te esetedben, ami heap corruptiont okozhat:
- valahol közben már kitörölted a tort tömböt, a destruktor is törölni szeretné és ez nem tetszik az oprendszernek
- zárójeles a new, delete pedig zárójel nélküli (ez az esetedben fenn áll)
muxik koszi, 5 elemu lett a tomb indexek 0-4 ig, mostmar jo a for ciklus.
(vagy nem értem)
.
ut);
Új hozzászólás Aktív témák
Hirdetés
● ha kódot szúrsz be, használd a PROGRAMKÓD formázási funkciót!
- Macron betiltatná az EU-ban a közösségi médiát a 15 év alattiaknak
- Kertészet, mezőgazdaság topik
- f(x)=exp(x): A laposföld elmebaj: Vissza a jövőbe!
- CURVE - "All your cards in one." Minden bankkártyád egyben.
- PR-Telecom
- Redmi Watch 5 - formás, de egyszerű
- Elektromos cigaretta 🔞
- Motorolaj, hajtóműolaj, hűtőfolyadék, adalékok és szűrők topikja
- Autós topik
- BestBuy ruhás topik
- További aktív témák...
- Megkimélt Apple iPhone 8 Plus 64GB Fekete szinben, 100% akkuval, kártyafüggetlen, garanciával
- Megkimélt Apple iPhone SE 2020 128GB kártyafüggetlen, fekete és fehér színben garanciával!
- Újszerű, karcmentes Samsung Galaxy Watch 6 Classic 47mm LTE (E-Sim) Ezüst
- GOPRO Hero 11 BLACK - 5.3k akciókamera - 2 akku, tartozékok (5.)
- DJI AVATA 2 Fly More Combo 1 akku - drón szett DJI Goggles N3 FPV szemüveggel
- Szinte új, minőségi, állítható ritkítóolló
- Vásárold meg most a Zalman T7-et, és élvezd a minőséget!
- Telefon felvásárlás!! iPhone 15/iPhone 15 Plus/iPhone 15 Pro/iPhone 15 Pro Max
- Xiaomi Redmi Note 13 Pro+ 512GB, Kártyafüggetlen, 1 Év Garanciával
- REFURBISHED - HP USB-C Dock G4 docking station (L13899-001)
Állásajánlatok
Cég: PC Trade Systems Kft.
Város: Szeged
Cég: PC Trade Systems Kft.
Város: Szeged