Legalabb a tetel osztalyt meg tudod irni magadtol? A finomsagokat meg tudom mondani, de ha egy osztalyt sem tudsz megirni, akkor mindenkepp ki fog derulni a dolog.

while (!sleep) sheep++;

Üdv!
A segítségeteket szeretném kérni:
Lehetséges egy osztály konstans példányának az adattagjait valahogyan mégis módosítani?
Hogyan kell az osztály adattagjainak típusát módosítani, hogy azok akkor is változtathatóak legyenek, ha az osztály egy példánya így lett létrehozva:

class alma
{
int a;
int b;
int db; // ezt akarom módosítani
...
{

const alma a;

Remélem érthető volt.
Köszönöm:
Orc

Kinyomom a szemed, eltöröm a lábad... aztán mehetsz amerre látsz!

Lehetséges cast vagy mutable használatával, de sokkal inkább el kellene kerülni.

Jester

Sziasztok!
Arra lennék kíváncsi, hogy hogyan tudok kiírni lpt portra? Az lpt port címe: 0x0378.

Mi meg arra lettünk volna kiváncsiak, hogy milyen operációs rendszer alatt.
Linuxon mindenesetre első közelítésben inkább a parport driver által szolgáltatott ioctl-ek használata javallott. Ha pedig mindenképp közvetlen portelérés kell akkor a megfelelő jogosultságok beállítása után inline asm vagy az előre definiált in/out függvénykkel lehet elérni.

Jester

Legjobb lenne a win 7 64 bit, de ha másképp nem oldható meg xp 32.
Visual studio 2008-at használok.

Sziasztok!

Egy kis segitséget szeretnék kérni. Még sosem csináltam ilyet, szal ugy kéne megfogalmazni a help-et
Szal a kérdésem, hogy hogyan lehet egy .lib-et használni egy C++ programban.
Jelen esetben a libcurl-t szeretném használni és Codeblocks-ot használok. Windows 7 alatt.

Ha valaki le tudná irni, hogy mit hova kell linkelgetnem, azt nagyon megköszönném.

#!/bin/perl -sp0777i<X+d*lMLa^*lN%0]dsXx++lMlN/dsM0<j]dsj $/= unpack( 'H*' , $_ ); $_ = `echo 16dio\U$k"SK$/SM$n\EsN0p[lN*1 lK[d2%Sa2/d0$^Ixp"|dc`;s/\W//g;$_=pack('H*',/((..)*)$/)

a forraskod szintjen csak annyi, hogy include-olod a szukseges .h file-okat, es hasznalod a libet
a lenyeg a linkelesnel jon, amikor is a forditonak meg kell adni a -llibraryneve kapcsolot (- kicsi L es a lib neve, pl. -lcurl)
hogy ezt pontosan hol tudod elmagyarazni neki, az IDE-tol fugg, biztos van a CB-ban is valami olyan ablak/ful ahol a hasznalando libraryket tudod megadni

Hát már próbáltam nagyon sok féleképpen, de nem igazán sikerül 1szer sem.
CB-ban kb 100szor végignéztem hogy hol lehetne ilyesmit linkelni, ahol lehetett ott linkeltem, de sehogysem akarta tudni használni:S
De próbálkozom még...

#!/bin/perl -sp0777i<X+d*lMLa^*lN%0]dsXx++lMlN/dsM0<j]dsj $/= unpack( 'H*' , $_ ); $_ = `echo 16dio\U$k"SK$/SM$n\EsN0p[lN*1 lK[d2%Sa2/d0$^Ixp"|dc`;s/\W//g;$_=pack('H*',/((..)*)$/)

Valami expert, de annyira nem rohadtnagy könyvet tudtok ajánlani, amit reggel az ember a villamoson/héven tud forgatni, de azért nem cseszi fel az agyát egyórás úton? Kéne. Valami nagyon mély c++ könyv. Elsősorban Linuxos oldalról közelítve.

I am having fun staying poor.

thinking in C++, effective C++ nagyon jo konyvek

Ezeket lehet valahol kapni idehaza? Első pár oldal google találatok között nem találtam meg ténylegesen. Mindenesetre nagyon gyorsan kéne valami.

I am having fun staying poor.

idehaza? vannak konyvesboltok (pl bookline talan) akik kulfoldrol hoznak be konyveket
de ha gyorsan kell, akkor marad a letoltes elektronikusan...
nem konkretan C++, de C++-os Qt programozasrol van ingyenesen elerheto konyv (pontosabban az elso kiadas letoltheto, a masodik csak papiralapon erheto el legalisan), valahol a Qt oldalan meg is van ra a link

Stroustrup könyve tulajdonképpen referenciakönyv néhány példával. Semmi linuxos anyagot nem találsz benne, gondolom ezért nem hangzott el.

egyreszt mert az a felveteseddel ellentetben rohadt nagy
masreszt meg az tanulni nem igazan jo, inkabb referencia, ha szeretned az alaptudast felboviteni, akkor rengeteget kell olvasnod belole hogy tenyleg belemelyedj. igaz, abban a konyvben minden benne van amit a C++ -rol tudni kell/lehet
a Linuxos vonatkozas megint mas, ez nem a nyelvtol fugg, hanem attol hogy milyen headereket/libeket hasznalsz. a hasznalt eszkozoket jol megvalogatva nem kell foglalkoznod azzal, hogy milyen OS van alattad, az en Qt-s es SDL-es programjaim platformfuggetlenek, az SDL-es jatekomat leforditottam mar pl. IRIX-re (Silicon Graphics) es WIZ-re (ARM procis jatekkonzol) is

egyedul akkor kell komolyan foglakoznod a nyelv es az OS kapcsolataval, ha rendszerszintu fejlesztesben gondolkodsz (pl. kernelmodulok, driverek, stb), errol is van szakirodalom

Ja tényleg, elég nagy. Viszont láttam egy kollégánál, s attól nagyobbra emlékeztem azért. Most minden nap viszek magammal egy adag nyomtatott részt a könyvből amit linkeltem. Az a lényeg abban amit most csinálok, hogy Linux alatt legyen a lehető legjobb megoldás, platformfüggetlenség igénye nem merül fel. De már most vannak olyan részek, amik másképp vannak kezelve win alatt meg linux alatt. Jelzések, processzek, osztott memória, dinamikus könyvtárak, ilyesmi.
[link]

I am having fun staying poor.

Sziasztok!
Meg tudnátok mondani, hogy miként kell használni ezt a függvényt, ha lpt portra akarok kiírni ill. onnan olvasni?
Egy egyszerű byte kiírásos, olvasásos példának nagyon örülnék.

[ Szerkesztve ]

Sziasztok!

Van egy függvényem,ami egy fileból kiolvas adatokat,az ott található értékeket alakítja át double értékké,ezeket berakja egy tömbe és ezeket az értékeket adja vissza visszatérési értékként.

A dolog teljesen jól működik a függvényen belül,amint azonban meghívom a függvényt érdekes visszatérési értékeket kapok.

Értsd:
ilyen formában vannak a számok pl 10.240 viszont amikor a függvényt meghívom,akkor mindig 1.31223+e09 és hasonló formátumba dobálja vissza.Van ötletetek,hogy ezt hogy lehetne megoldani,mert én egyenlőre nem találtam semmit.

Előre is kösz a válaszokat!

Üdv!

Valószínűleg elrontottad a visszaadást. Tipikus hiba lokális változó címének visszaadása. Erre egyébként szoktak a fordítók warningot dobni (már ha veszed a fáradságot, hogy bekapcsold) warning: address of local variable returned

Jester

ez viszont nem C++, hanem sima C (leven maga a Linux kernel is C-ben keszul)
ehhez meg nagyon jo pl. a Kiskapu altal kiadott 'UNIX-GNU/Linux Programozas C nyelven' c konyv, ami meg vekony is raadasul (250 oldal)

üdv, kellene egy kis segítség valahogy kő-papír-olló-t el kellene készíteni switch-case segítségével de sehogy se jövök rá.

hello!

sajnos nincs most elottem c fejlesztokornyezet, de en igy csinalnam:

- bekernek az usertol egy szamot ellenorzotten (1 - ko, 2 - ollo, 3 - papir)
- aztan a randomolnek 1 es 3 kozott egy szamot, ami a gep valasztasa lesz
- osszehasonlitanam a 2 erteket
- aztan kiirnam ki nyert, esetleg ha tobb "menetes", akkor egy userpont, computerpont valtozokban tarolnam az eddig gyozelmek szamat

remelem tudtam segiteni.

some men just wanna watch the world burn...

Sziasztok!

Hogy lehetne azt megoldani,hogy a program egy megadott elérési útról is megtudja nyitni a filet ?

Tehát pl.: nem azt adom meg bemenetnek,hogy valami.txt hanem hogy C:\itt\ott\valami.txt

Nem a szétbontással van a gondom,azt megtudom csinálni,hanem azzal,hogy a program így is lefusson,azaz a megadott elérési útnak megfelelően futtassa a filet.

Előre is köszönöm a válaszokat!

Hello!

Megoldandó probléma az lenne, hogy minden ponthoz húzni kéne egy egyenest... Valószínűleg a belső ciklusommal van a baj..., mert az csak annyit csinál, hogy az utolsó pontnál húz egy vonalat mindegyik pontba, kivéve az elsőhöz, arra szolgál az utolsó sor. Természetesen ha egyszer már egy átló megvan húzva, akkor nem kéne hogy az mégegyszer megismétlődjön, de arról lővésem sincs, hogyan kéne.

[code]
for (int i=0;i<N;i++)
{
lineto(int (pontok.x), int (pontok(i).y));
for(int j=i+1; j<N; j++)
{
lineto(int (pontok[j].x), int (pontok[j].y));
}
}

lineto(int (pontok[0].x), int (pontok[0].y));
Ezzel a résszel akadtak problémáim

[/code]

nem igazan ertem, mit szeretnel? minden pontot osszekotni, vagy a kezdopontbol huzni vonalat az osszesbe?
altalanos jo tanacs: probald meg papiron rajzolni mit csinal az algoritmusod

Nem vagyok egoista, csak uborkagyalu!

Sziasztok!

Egy külső forrást (.txt) kellen beolvasni, aztán kiírni belőle tetszőleges adatokat. Ezzel nem is lenne probléma.

Tegyük fel, hogy ilyen sorokkal van tele a txt:

1 2 3 vezetéknév keresztnév

Az első 3 adatot simán beolvasom minden sorból, a 4. és 5.-el viszont gondba vagyok. El tudnám tárolni 4.-nek egy tetszőleges változóba, de ugye a 4. csak a vezetéknév és nekem a vezetéknevet és keresztnevet egybe kellene tudnom kilistázni, egy változóba. C#-ből ugye ismerjük az összevonó operátort, csak azt se nagyon tudnám használni ilyen formában, mivel a változó kiiratásakor kéne lennie egy szóköznek a vezetéknév és a keresztnév között. Meg lehet ezt valahogy oldani? Köszi.

#include <iostream>
#include <fstream>
using namespace std;

int main()
{
int a;
int b;
int c;
string vez;
string ker;
string nev;
fstream f;
f.open("valami.txt");
f>>a>>b>>c>>vez>>ker;
nev=vez+" "+ker;
cout << a << endl << b << endl << c << endl << vez << endl << ker << endl <<nev;
f.close();
return 0;
}

[ Szerkesztve ]

Huh, köszönöm a gyors választ!

Sziasztok!
Valaki segítsen nekem legyen szíves.
Megírtam egy fifo osztályt, de valami probléma van, mert a program nem fut le normálisan, annak ellenére, hogy minden hiba nélkül lefordul.

fifo.h
#ifndef fifo_h
#define fifo_h

class FiFo{
int elementNum;
double*pData;
public:
FiFo();
FiFo(const FiFo&theOther);
~FiFo();
double get();
bool put(double element);
bool empty();
};

#endif

fifo.cpp
#include "fifo.h"
#include<stdio.h>

FiFo::FiFo()
{
elementNum=0;
pData=0;
}

FiFo::FiFo(const FiFo&theOther)
{
if(theOther.elementNum==0)
{
elementNum=0;
pData=0;
}
else
{
elementNum=theOther.elementNum;
pData=new double[elementNum];
for(int i=0;i<elementNum;i++)
{
pData[i]=theOther.pData[i];
}
}
}

FiFo::~FiFo()
{
delete[]pData;
}

double FiFo::get()
{
if(elementNum==1)
{
double element=pData[0];
delete[]pData;
elementNum=0;
return element;
}
elementNum--;
double element=pData[0];
double*pTemp=new double[elementNum];
for(int i=0;i<elementNum;i++)
{
pTemp[i]=pData[i+1];
}
delete[]pData;
pData=pTemp;
return element;
}

bool FiFo::put(double element)
{
double*pTemp=new double[elementNum+1];
elementNum++;
for(int i=0;i<elementNum-1;i++)
{
pTemp[i]=pData[i];
}
pTemp[elementNum-1]=element;
delete[]pData;
pData=pTemp;
return true;
}

bool FiFo::empty()
{
elementNum=0;
pData=0;
return true;
}

Mi lehet a baj?
Előre is kösz.
Üdv.: Papa019

[ Szerkesztve ]

1, Ha csinálsz egy olyat, hogy
delete pData; akkor csináld így:
if (pData!=null) {
delete pData; pData = null;
}

Ha úgy próbálsz felszabadítani, hogy a pData-t már egyszer felszabadítottad, el fog szállni futás közben, ezért a null-ra állítással jelzed magadnak, hogy felszabadítottad-e vagy sem.

Meg engem eléggé zavar, hogy pData=0; -t használsz pData=null; helyett.

2, A get()-nél nem ellenőrzöd, hogy elementNum elérte-e a nullát, mert ha igen, akkor a pData[0]-tól semmi jót ne várj.

3, az empty()-nél is ez kéne:
if (pData!=null) {
delete pData; pData = null;
}

4, Nagyon nem hatékony, hogy minden egyes beszúrásnál és törlésnél újrafoglalod a tömböt meg átmásolgatod az elemeket. Célszerűbb lenne egy oda-vissza láncolt lista.

Remélem tudtam segíteni! Ha null-t Null-nak vagy NULL-nak kell itt írni, akkor sorry, mostanában inkább java-zok...

Meg engem eléggé zavar, hogy pData=0; -t használsz pData=null; helyett.
ezzel en is sokaig igy voltam C -> C++ valtas utan, de a '0' a C++ 'standard', es egy ideje mar en is igy hasznalom (bar valoban nem kimondottan logikus, a NULL sokkal jobban leirja hogy mi is tortenik a mutatoval mint egy sima numerikus ertek)

Ha bármely két pont között akarsz pontosan egy irányítatlan szakaszt, akkor az ennyi:

for (int i=0; i<N; i++) {
for (int j=i+1; j<N; j++) {
lineto (i, j);
}
}

Bár nem tudom, hogy megy ez a lineto...
Ha két lineto kell egy szakaszhoz úgy, hogy először a kezdőpontot adod meg, aztán a végpontot, akkor a belső ciklusban két lineto kell így:

for (int i=0; i<N; i++) {
for (int j=i+1; j<N; j++) {
lineto (pont(i).x, pont(i).y);
lineto (pont[j].x, pont[j].y);
}
}(/I)

Nem működő programok esetén
1) használj debuggert
2) használj memória-hozzáférés ellenőrzőt (valgrind)
3) mondd meg pontosan milyen bemenetre milyen hibát ad, vagy mennyiben nem várt eredményt (a "nem fut le normálisan" nulla információ)
4) teljes, futtatható programot postolj, hogy mi is ki tudjuk próbálni (ebben ugye nem volt main)

Jester

Oké. Megfogadom a tanácsaid.
A nem fut le normálisan alatt azt értem, hogy a copy konstruktor használata esetén a cmd megállt futás közben, illetve amikor a destruktor nem volt kikommentezve, akkor is tapasztaltam ezt a jelenséget.
ez a main.cpp tartalma:
#include "fifo.h"
#include<stdio.h>

void main(){
FiFo valami;
valami.put(3.14);
valami.put(6.14);
valami.put(1.23);
valami.put(7.23);
valami.put(6.79);
printf("%lf\n",valami.get());
printf("%lf\n",valami.get());
printf("%lf\n",valami.get());
printf("%lf\n",valami.get());
printf("%lf\n",valami.get());

/*FiFo valami1(valami);
FiFo valami2=valami;

printf("%lf\n",valami1.get());
printf("%lf\n",valami1.get());
printf("%lf\n",valami1.get());
printf("%lf\n",valami1.get());
printf("%lf\n",valami1.get());*/
}

Köszönöm a sok segítséget, megpróbálom kijavítani a tanácsaitok alapján.
Ezt a pData=0-t így tanítják nekünk az egyetemen... :S Eddig én is NULL-t használtam, aztán a gyakvezérünk minden programot 0-val írt fel :S

A tömb újrafoglalgatása azért van, mert most kezdtünk bele a nyelvbe és még nem bonyolítjuk láncolt listával. (én meg inkább a gyakorlati anyag alapján írom meg a házimat

Mégegyszer köszönöm a hozzászólásokat.
Ha esetleg lesz valaki, aki megnézi a programom a main.cpp-vel, és úgy talál valami hibát benne, akkor kérem értesítsen.

#include "fifo.h"
#include<stdio.h>

FiFo:iFo()
{
elementNum=0;
pData=0;
}

FiFo:iFo(const FiFo&theOther)
{
if(theOther.elementNum==0)
{
elementNum=0;
pData=0;
}
else
{
elementNum=theOther.elementNum;
pData=new double[elementNum];
for(int i=0;i<elementNum;i++)
{
pData=theOther.pData(i);
}
}
}

FiFo::~FiFo()
{
if (pData) {
delete [] pData;
pData = 0;
}
}

double FiFo::get()
{
if (elementNum==0) {
return 0;
}

if(elementNum==1)
{
double element=pData[0];
if (pData) {
delete [] pData;
pData = 0;
}
elementNum=0;
return element;
}
elementNum--;
double element=pData[0];
double*pTemp=new double[elementNum];
for(int i=0;i<elementNum;i++)
{
pTemp(i)=pData[i+1];
}
if (pData) {
delete [] pData;
pData = 0;
}
pData=pTemp;
return element;
}

bool FiFo::put(double element)
{
double*pTemp=new double[elementNum+1];
elementNum++;
for(int i=0;i<elementNum-1;i++)
{
pTemp(i)=pData(i);
}
pTemp[elementNum-1]=element;
if (pData) {
delete [] pData;
pData = 0;
}
pData=pTemp;
return true;
}

bool FiFo::empty()
{
elementNum=0;
if (pData) {
delete [] pData;
pData = 0;
}
return true;
}

Alapból a destruktorban szállt el, hiszen a get()-nél mikor kivetted az utolsó elemet, már felszabadítottad a pData-t, a destruktor pedig még1x megpróbálta ezt megtenni.

Örök hálám.

[ Szerkesztve ]

Sziasztok!

Egy kérdésem volna.
Van egy fájlom, amit binárisan egy char[] tömbbe beolvasok.
A fájlom bájtokat tartalmaz. Bizonyos méret felett azonban negatív értéknek veszi.
Pl. tartalmazza ezt a fájlom: 6C 18 0 43 92 EC
majd beolvasás, majd kiirítás utána az első 4 érték helyes, a többi: FFFFFF92, FFFFFFEC, tehát pont "mínusz" mint a szám.

Ötlet?
Kösz!

Kitaláltam közbe. a fájlból char tömbbe olvastam be, átírtam unsigned char-ra és most jó. Azt hittem elfér sima char tömbbe is a dolog :S

[ Szerkesztve ]

A byte adattípus az az unsigned char másnéven. Nem az a baj, hogy nem fér be a char-ba, hanem hogy az előjelet is kezel, míg az unsigned csak természetes számokkal dolgozik.

Sziasztok!

Egy fájlból kéne kiolvasnom adatokat, soronként tartalmaz mondjuk egy számot és egy nevet, az első sorban a sorok száma, pl:

5
1 Aladar
2 Peter
2 Aniko
3 Erno
1 Tibor

Addig eljutottam, hogy beolvasom az adatokat és ki tudom íratni, hogy n-edik sorban milyen szám vagy név van. Viszont összetettebbek már nem mennek, például, hogy azokat a neveket irassam ki, amely sorokban a szám=1. OK, létrehozok egy változót 1-es értékkel, tömbbe pl. mintatömb[változó].név és végigmegyek mondjuk for-al a sorokon, akkor ki tudom listázni, hogy milyen nevek vannak, de ennek jelen pillanatban nem sok hasznát veszem, tehát az alapok mennek. De ha mondjuk már megvan a szám, akkor azt nem tudom, hogy annak a sornak a neveit irassa ki, mert ugye a tömbbe is kell valamit írni, így hibát kapok: mintatömb[].név. Lehet, hogy nem struct-al kéne megoldani ezt?

Itt a forrás, így érthetőbb.

[ Szerkesztve ]

Szia,

Első körben két problémát látok:
1, Write() meg Load() függvényeknek fordított sorrendben kéne lennie, mert egy inicializálatlan arrayből nem tudom mit akarsz kiíratni.
2, A Load()-ban a második paramétert tök felesleges referenciaként átadni, nem a tömb címét írod át, hanem a memóriacímen lévő adatokat piszkálod. Ha ez nem világos, amit írtam, akkor bővebben kifejtem. (Referencia helyett inkább const lenne a logikus szvsz.)

Még most talán lényegtelen, amíg az alapok nem mennek, de dinamikusan kéne a tömböt lefoglalni menet közben, mert nem tudni, hány sor lesz a fájlban. Ezt így tudod megtenni, hogy: example * tomb = new example[n]; ahol n-et a fájl első sorából olvasod be. Bár ha dinamikusan foglalod le, akkor értelmet nyer a referencia, mert akkor a függvényen belül derül ki a címe. Felszabadítás pedig: delete [] tomb;

Ha pl. azokat a neveket akarod kinyerni, amelyeknél 2 van a név előtt, akkor egy for ciklus a tömbbön és ha if (something.day == 2) cout << something(i).name << endl;

Még valami:
Azzal a continue-val mit akartál elérni a végefelé??

[ Szerkesztve ]

1. Azt a példát csak gyorsan összedobtam, azért vannak felcserélve, véletlenül.
2. Ezt kifejthetnéd bővebben.

A dinamikus tömbökről már korábban tanultam, csak most még nem jut eszembe használni, de kipróbálom így is.

A something.day viszont továbbra sem működik, mert alapvetően így olvastam be ugye az adatokat, hogy something[i].day, tehát dob egy szokásos hibaüzit, hogy .day must have a class/struct/union, tudod. Vagy ezt már a dinamikus tömbökkel kéne és menni fog?

A continue egy korábbi while-ból véletlenül maradt bent, figyelmetlen vagyok.

[ Szerkesztve ]

Egyébként ha csak azért jó a dinamikus tömb, mert nem lehet tudni, hogy hány sor lesz, akkor egy sima tömbbe beírok mondjuk 100-at (a feladatban az van, hogy maximum 100 lehet) és el lehet felejteni a dinamikus tömböket, vagy van más előnye is?

Egyrészt ezt így próbáld ki, nekem így simán működik:

#include <stdio.h>
#include <iostream>
#include <fstream>
#include <string>

using namespace std;

struct example
{
int day;
string name;
};

typedef example array[5];

int load(int& counter, array something);
int write(array something);

int main()
{
int counter;
array something;
load(counter, something);
write(something);

getc(stdin);
return 0;
}

int load(int& counter, array something)
{
ifstream file;
file.open("file.txt");
file >> counter; //<- #2 PROBLEM
for(int i=0; i<counter; i++)
{
file >> something.day;
file >> something(i).name;
cout << something(i).day << " " << something(i).name << endl;
}
file.close();
return 0;
}

int write(array something)
{
int one=1;
if(something[one].day)
cout << something[one].name; //<- #1 PROBLEM
/*else
continue;*/
return 0;
}

Referencia, cím, stb:

ha van egy tömböd, pl. int tomb[5];
akkor ha csak simán ezt írod le, hogy pl(sorry a c-s kiíratásért, én azt szeretem):
printf("%d",tomb); -> a tömb memóriacíme
tomb[0] -> a tomb memóriacíménél lévő int elem
tomb[1] -> a tomb címéhez képest egy inttel arrébb lévő elem
tomb[2] -> a tomb címéhez képest két inttel arrébb lévő elem

tomb + 0 -> a tomb első elemének, avagy a tömbnek a memóriacíme
tomb + 1 -> a tomb második elemének a címe

*(tomb + 0) -> a * rámutat a zárójelben lévő címre, azaz az ottani int értéket jelenti

az és(&) jel több dologra jó, most kettőre térek ki:

1. Cím lekérése
van egy ilyen változód, hogy:
int i = 5;
&i ennek az i változónak a címét jelenti a memóriában.
Ha pointerezel: *(&i) az i címére mutató pointer, tehát maga az i.

2. Referencia (nem tudom milyen nyelvekben vagy jártas, pascalban pl. ez a var kulcsszó, ill. sok nyelvben meg mindig referencia szerinti átadás van, mint pl. java - persze vannak kivételek

int i = 5;
int & j = i; // az i "álneve" vagy "aliasa" j lesz

itt a j egy és ugyanaz a változó, mint az i, tehát ha ezt csinálod, hogy
j = 6;
akkor az i is 6 lesz, mivel a két változó ugyanaz, csak két különböző néven tudod őket elérni.

ha van egy függvény, ami referenciát vár, pl:

void inc (int & j) {
j++;
}

int i = 5;
inc (i);

akkor ennek a függvénynek a paramétere egy alias lesz i-re, tehát ha a függvényben megváltoztatod j-t, azzal i-t változtatod. Szal a referencia arra van általában, hogy a bemeneti paraméter kimeneti is lehessen ill. még azért használják, mert ez egy dereferált pointer a beadott paraméterre és ha az a paraméter nagyobb helyet foglal, mint egy pointer, akkor nem kell lemásolni a beadott értéket az újonnan létrehozott ugyanolyan nagy paraméterváltozóba. Ha az utóbbi félmondatot még nem érted, nem nagy gond.

Szóval te egy függvénynek átadtad referenciaként egy tömb címét. Ezt a címet te nyilván nem akarod megváltoztatni, mert akkor a memóriában ki tudja honnan olvasnál be dolgokat.
Kíváncsi vagyok, hogy ebből mit értettél meg...

Nincs más előnye azon kívül, hogy csak annyi helyet foglal, mint amennyit kell. Annyi, hogy máshogy foglalódik le a new-val meg a fixen lefoglalt tömb. Ennek számodra most semmi jelentősége.

[ Szerkesztve ]

Ja a cím szerinti átadás világos, elsőre azt hittem, hogy valami komolyabbról van szó (ezt most úgy mondtam, mintha akkora májer lennék, mindegy ).

Lefuttatom az általad bemásolt kódot és ugyanaz a hibaüzi, nem adhatsz meg csak simán something-et osztálynak, mert egy array-be vannak, mindenképpen ott kell lennie a [ ]-nek. Szerintem ez az egész alapvetően nem alkalmas arra, amit szeretnék, mert bárhogy próbálom, mindig ugyanahhoz a hibához lyukadok ki.

Azt kellene megvalósítanom, hogy miközben végigmegy a sorokon (pl. for szerkezettel) kilistázza azoknak a soroknak a neveit, amikben a szám == 2, például.

Tehát hiába hozok létre egy változót mondjuk 2 értékkel és írom be a tömbbe, pl.: something[változó].szam, mert utána nem írhatom azt, hogy something.nev, ez egy ördögi kör.

[ Szerkesztve ]

Nálam semmi hibaüzi nincs, visual studio + winXP.
Annak, hogy something.nev semmi értelme, mert a something az egy tömb, neki nincs olyan mezője, hogy nev. A something struktúrák tömbbje, a tömbnek van [i.] eleme, ennek az i. elemnek vannak mezői, mert ez a struktúra. Valahol nagyon kavarhatsz vmit.
Miért nem jó neked, ha azt írod, hogy something[változó].nev???

[ Szerkesztve ]

file >> something.day; - na ezt nem tudom miért ebben a formában sikerült beillesztenem.
A something után kell az indexelés: file >> something.day;