C++, Delphi, JAVA és egyéb programnyelvek

[Gregory]

Eleinte asszem ilyen vagány dolgokat csináltak, hogy exploitolnak valami IE bugot, hogy ráfusson a kommentre és éttelmezze azt is, meg hasonlóak.
Google segített, van kvázi-korrekt megoldás is az IE és a világ többi részének elkülönítésére: http://www.quirksmode.org/css/condcom.html

[Xzone]

Ebben látja a hibát valaki? Bináris fát kellene építenie egy fájlból(abc.txt), ami így néz ki, idézőjelek nélkül: "A.- B-... C-.-. D-.. E. F..-. G--. H.... I.. J.--- K-.- L.-.. M-- N-. O--- P.--. Q--.- R.-. S... T- U..- V...- W.-- X-..- Y-.-- Z--.. ". De nem teszi

Code Select Expand

#include <stdio.h>
#include <stdlib.h>

int main(void)
{
    typedef struct morsetree { char betu;
                    struct morsetree *ti, *ta;
                  } morse, *morsefa;
    FILE *f;
    char c1, c2;
    morsefa gyoker, futo;
gyoker=NULL;

    if((f=fopen("abc.txt", "rt"))==NULL)
    {
        printf("HIBA");
        return 0;
    }

    while((c1=fgetc(f))!=EOF)
    {
        futo=gyoker;
        while((c2=fgetc(f))!=' ')
        {
            if(futo==NULL)
            {
                futo=((morsefa)malloc(sizeof(morse)));
                futo->ti=futo->ta=NULL;
            }
            if(c2=='.')
            {
                futo=futo->ti;
            }
            if(c2=='-')
            {
                futo=futo->ta;
            }
        }
        futo->betu=c1;
    }

    printf("%c\n", gyoker->ti->betu);
    return 0;
}

[Manitu]

A belső while-ban a futo=futo->ti és futo=futo->ta. A jobb oldali tag az értékadáskor mindig NULL lesz. Amikor aztán lefoglalod neki a memóriát, akkor nem kapcsolod hozzá az előző elemhez. Valami pointert kellene inkább eltárolni a futo->ti és a futo->ta elemekre, nem pedig az értéküket.

[Xzone]

Tweakeltem egy kicsit a dolgot(lehet, hogy túlbonyolítottam). Már legalább lefut, és szerintem fel is építi a bináris fát, csak rosszul, heh.

Code Select Expand


#include <stdio.h>
#include <stdlib.h>

int main(void)
{
    typedef struct morsetree { char betu;
                    struct morsetree *ti, *ta;
                  } morse, *morsefa;
    FILE *f;
int n;
    char c1, c2;
    morsefa gyoker, futo, futo2;
gyoker=(morsefa)malloc(sizeof(morse));
gyoker->ti=gyoker->ta=NULL;
    if((f=fopen("abc.txt", "rt"))==NULL)
    {
        printf("HIBA");
        return 0;
    }

    while((c1=fgetc(f))!=EOF)
    {
n=0;
        futo=futo2=gyoker;
        while((c2=fgetc(f))!=' ')
        {
            if(c2=='.')
{
if(n==0)
{
if((gyoker->ti)==NULL)
{
futo=((morsefa)malloc(sizeof(morse)));
futo->ti=futo->ta=NULL;
gyoker->ti=futo;
}
else
{
futo=gyoker->ti;
}
}
else
{
if((futo->ti)==NULL)
{
futo->ti=futo2=((morsefa)malloc(sizeof(morse)));
}
else
{
futo2=futo->ti;
}
}
}
if(c2=='-')
{
if(n==0)
{
if((gyoker->ta)==NULL)
{
futo=((morsefa)malloc(sizeof(morse)));
futo->ti=futo->ta=NULL;
gyoker->ta=futo;
}
else
{
futo=gyoker->ta;
}
}
else
{
if((futo->ta)==NULL)
{
futo->ta=futo2=((morsefa)malloc(sizeof(morse)));
}
else
{
futo2=futo->ta;
}
}
}
n++;
}
futo2->betu=c1;
}
    printf("%c\n", (gyoker->ti)->betu);
    return 0;
}


[Manitu]

A kiíratás nem jó, a gyoker->ti->betu kifejezésnek csak akkor van értelmes értéke, ha a "." karaktert olvassod be a fájlból, de ilyen betű nincs a morse ábécében Eleve a betu tagot nem is inicializálod sehol.
A fában különböző mélységben vannak a különböző betűk, szóval így biztos nem tudod kiolvasni belőle. Valami ciklus kell oda, ami bejárja a fát, a levelekben lesznek a betűk.

Jobban megnézve az első verziónak is működnie kéne, az is felépíti a fát, csak rosszul olvasod ki a végén. Kicsit benéztem azt a typedefet

Amúgy meg aki mallocot mond, az mondjon freet is, hol van a cleanup?

[Xzone]

Egyelőre még építeni próbálom a fát, a lerombolása csak utána jön

Azt hittem egyébként, hogy azért nem megy a kiíratás, mert nincs ott semmi, roszul van felépítve a fa.

[Manitu]

Nem hiszem, próbáld ki például a gyoker->ti->ta->betu -t, ott kell lennie az A-nak.

[Xzone]

Az első továbbra is kifagy, a második(a bonyolult) meg kidobja a W-t a gyoker->ti->ta-ra

Egyszer majd csak összejön(nagyon köszi a segítséget egyébként ). Végülis péntekig elszórakozhatok ezzel a progival, de akkor buktam 5 kreditet egy másik tantárgy miatt, amivel foglalkoznom kellene. Viszont ha ez nincs meg péntekig, 7-et veszítek. Lose-lose, de szerintem érdemesebb ezt befejezni(ez csak az alapja amúgy, csak erre a fára akarom ráépíteni a progi többi részét).

[Manitu]

Fene a hülye formámat, ha valamin elkezdek gondolkodni, akkor nem nyugszok, amíg rá nem jövök, mi a megoldás.
Kicsit túlbonyolítottad, nem kell ciklusszámláló, és ennyi átmeneti változó sem, csak jól el kell tárolni, hol jársz éppen a fában.
Ez így működik, az érvénytelen kódok helyén ' ' van a betu-ben, ha érvényes, akkor meg a megfelelő betű. (Csúnyák azok az inicializálatlan charok )
A többi már a te dolgod

Code Select Expand

#include <stdio.h>
#include <stdlib.h>

int main(void)
{
    typedef struct morsetree { char betu;
                    struct morsetree *ti, *ta;
                  } morse, *morsefa;
    FILE *f;
    char c1, c2;
morsefa gyoker, futo;
gyoker=(morsefa)malloc(sizeof(morse));
gyoker->ti=gyoker->ta=NULL;
gyoker->betu = ' ';
if((f=fopen("abc.txt", "rt"))==NULL)
    {
        printf("HIBA");
        return 0;
    }

    while((c1=fgetc(f))!=EOF)
    {
        futo=gyoker;
        while((c2=fgetc(f))!=' ')
        {
            if(c2=='.')
{
if((futo->ti)==NULL)
{
futo->ti=((morsefa)malloc(sizeof(morse)));
futo->ti->ta=futo->ti->ti=NULL;
futo->ti->betu = ' ';
futo = futo->ti;
}
else
{
futo=futo->ti;
}
}
if(c2=='-')
{
if((futo->ta)==NULL)
{
futo->ta=((morsefa)malloc(sizeof(morse)));
futo->ta->ti=futo->ta->ta=NULL;
futo->ta->betu = ' ';
futo = futo->ta;
}
else
{
futo=futo->ta;
}
}
}
futo->betu=c1;
}

    printf("%c\n", (gyoker->ti)->betu);

    return 0;
}

[Xzone]

Fene a hülye formámat, ha valamin elkezdek gondolkodni, akkor nem nyugszok, amíg rá nem jövök, mi a megoldás.
Kicsit túlbonyolítottad, nem kell ciklusszámláló, és ennyi átmeneti változó sem, csak jól el kell tárolni, hol jársz éppen a fában.
Ez így működik, az érvénytelen kódok helyén ' ' van a betu-ben, ha érvényes, akkor meg a megfelelő betű. (Csúnyák azok az inicializálatlan charok )
A többi már a te dolgod

Code Select Expand

#include <stdio.h>
#include <stdlib.h>

int main(void)
{
    typedef struct morsetree { char betu;
                    struct morsetree *ti, *ta;
                  } morse, *morsefa;
    FILE *f;
    char c1, c2;
morsefa gyoker, futo;
gyoker=(morsefa)malloc(sizeof(morse));
gyoker->ti=gyoker->ta=NULL;
gyoker->betu = ' ';
if((f=fopen("abc.txt", "rt"))==NULL)
    {
        printf("HIBA");
        return 0;
    }

    while((c1=fgetc(f))!=EOF)
    {
        futo=gyoker;
        while((c2=fgetc(f))!=' ')
        {
            if(c2=='.')
{
if((futo->ti)==NULL)
{
futo->ti=((morsefa)malloc(sizeof(morse)));
futo->ti->ta=futo->ti->ti=NULL;
futo->ti->betu = ' ';
futo = futo->ti;
}
else
{
futo=futo->ti;
}
}
if(c2=='-')
{
if((futo->ta)==NULL)
{
futo->ta=((morsefa)malloc(sizeof(morse)));
futo->ta->ti=futo->ta->ta=NULL;
futo->ta->betu = ' ';
futo = futo->ta;
}
else
{
futo=futo->ta;
}
}
}
futo->betu=c1;
}

    printf("%c\n", (gyoker->ti)->betu);

    return 0;
}

Most legalább egy rekesz sörrel jövök neked

[kikuchiyo]

Numerikus analízishez értők segítségét kérném.

A hővezetési egyenletet kellene numerikusan integrálni.
Ebben az alakban írom fel:

ro c dT/dt = div(K grad T) + Q

ro a sűrűség, c a fajhő, K a hővezetési tényező, és Q a rendszerbe melegítéssel (pl. mikrohullámmal) bevitt hő. Ezek a mennyiségek a helytől függenek, de az időtől nem. Mivel a kísérleti eszközünkben az érdekes tartomány henger alakú, logikusnak látszik hengerkoordinátákban felírni az egyenletet, ekkor nincs fi- és z-függés, és az egyenlet egydimenzióssá redukálódik:

ro(r) c(r) dT(r,t)/dt = 1/r d/dr(K(r) r dT(r,t)/dr) + Q(r)

Hogy érdemes ezt diszkretizálni (numerikus stabilitás és hasonlók szempontjából)? Ha kifejtem a d/dr-es tagot, megjelenik a K deriváltja is:

1/r d/dr(K r T') = T'' + K/r T' + K'T'

Ilyenre gondoltam első közelítésben (FTCS módszer):

click

Minden r-től függő mennyiséghez fel van véve egy N elemű tömb, annak az alsó indexben n. elemei szerepelnek a fenti képletben. K'-t is az elején gondoltam kiszámítani, és azt is egy tömbbe eltárolni. Fizikailag amúgy sincs nagy jelentősége annak a tagnak, csak akkor, ha folytonosan változnak a tesztcsőben lévő anyag tulajdonságai. Ebből az egyenletből kell kifejezni T^(j+1)-et, azaz a következő időlépésbeli hőmérsékleteket.

Szóval: ötletek, tippek, amidoinitrite?

[kikuchiyo]

Köszi mindenkinek a segítséget (), erre jutottam, ha érdekel valakit:

[spoiler]

Code Select Expand

#include<stdio.h>
#include<stdlib.h>
#include<math.h>

double* vallocd(int n) {
double *vek;

vek = (double *) calloc(n,sizeof(double));
if(vek == NULL) {
fprintf(stderr,"Memory allocation error\n");
exit(13);
}
return vek;
}

void initvecLinear(double *vec, int vsize, double initval0, double initval1) {
int i;

for (i=0;i<vsize;i++) {
vec[i] = initval0 + i*initval1;
//printf("%lf\t", vec[i]);
}
//printf("\n");
}

void initvecStep(double *vec, int vsize, int *initstepsArr, double *initvalsArr) {
int i, k, d;

i = 0;
d = initstepsArr[0];
while (i<vsize) {
for (k=0;k<d;k++) {
for (i=((k==0)?0:initstepsArr[k]);i<((k==d)?vsize:initstepsArr[k+1]);i++) {
vec[i] = initvalsArr[k];
// printf("%lf\n", vec[i]);

}
}
}

}

void calckprime(double *vec0, double *vec1, int vsize, double scale) {
int i;
double sc;

sc = 0.5 * ((double) vsize) / scale;
vec1[0] = vec0[1] - vec0[0];
for (i=1;i<vsize-1;i++) {
vec1[i] = sc * (vec0[i+1] - vec0[i-1]);
}
vec1[vsize-1] = vec0[vsize-1] - vec0[vsize-2];
/*for (i=0;i<vsize;i++) {
printf("%lf\t", vec1[i]);
}
printf("\n");*/

}

void calcrinv(double *vec, int vsize, double scale) {
int i;
double sc;

sc = ((double) vsize) / scale;
vec[0] = sc*3;
for (i=1;i<vsize;i++) {
vec[i] = sc / i;
}
/*for (i=0;i<vsize;i++) {
printf("%lf\t", vec[i]);
}
printf("\n");*/

}


int main(int argc, char *argv[]) {
double *T0, *T1, *sar, *roinv, *cinv, *k, *kprime, *rinv, *tempptr;
double t, dt, drinv, tmax, scale, c0, k0, ro0, T00, sar0, Tbound, s;
int i, imax;
FILE *fki, *fparam;

/***********************************************/
/*Default set of initial values*/
scale = 0.015; //m
imax = 300; //
dt = 0.001; //s
tmax = 2000.0; //s
T00 = 28; //degC
ro0 = 1000.0; //kg/m^3
c0 = 4200.0; //J/kg/degC
k0 = 0.5; //W/m/degC
sar0 = 0; //W/kg
Tbound = 40; //degC
/***********************************************/

/*checking arguments*/
if (argc < 2) {             
fprintf(stderr,"Usage: hovezetes out_file\n");
exit(1);
}

/*opening parameter file*/
fparam = fopen(argv[1],"r");
if (fparam == NULL) {
fprintf(stderr,"Could not open parameter file\n");
exit(2);
}

/*opening file for output*/
fki = fopen(argv[2],"w");
if (fki == NULL) {
fprintf(stderr,"Could not open output file\n");
exit(3);
}

/*Parsing parameters*/

/**TODO***/

drinv = ((double) imax) / scale;

/*Allocating vectors*/
T0 = vallocd(imax);
T1 = vallocd(imax);
roinv = vallocd(imax);
sar = vallocd(imax);
cinv = vallocd(imax);
k = vallocd(imax);
kprime = vallocd(imax);
rinv = vallocd(imax);

/*Filling them with their initial values*/
initvecLinear(T0, imax, T00, 0);
initvecLinear(T1, imax, T00, 0);
initvecLinear(roinv, imax, 1/ro0, 0);
initvecLinear(cinv, imax, 1/c0, 0);
initvecLinear(k, imax, k0, 0);
calcrinv(rinv, imax, scale);
calckprime(k, kprime, imax, scale);

/*Applying boundary condition*/

T0[imax-1] = Tbound;
T1[imax-1] = Tbound;


for (t=0;t<tmax;t+=dt) {
for (i=imax-2;i>=1;i--) {
s = k[i]*roinv[i]*cinv[i];
T1[i] = T0[i]+(s*drinv*drinv*(T0[i+1]-2*T0[i]+T0[i-1])+0.5*drinv*(kprime[i]*roinv[i]*cinv[i]+s*rinv[i])*(T0[i+1]-T0[i-1])+sar[i]*cinv[i])*dt; //long line is looong
}
s = k[0]*roinv[0]*cinv[0];
T1[0] = T0[0] + (s*drinv*drinv*(2*T0[1]-2*T0[0])+0.5*drinv*(kprime[0]*roinv[0]*cinv[0]+s*rinv[0])*(T0[1]-T0[0])+sar[0]*cinv[0])*dt;
//T1[0] = T0[1];
if (floor(t+dt)-floor(t)>=1) {
for (i=0;i<imax;i++) {
fprintf(fki, "%lf\t", T1[i]);
}
fprintf(fki, "\n");
}

tempptr = T1; //swapping pointers is easier than copying the entire array
T1 = T0;
T0 = tempptr;
}

fclose(fki); fclose(fparam);
free(T0); free(T1); free(sar); free(roinv);
free(cinv); free(k); free(kprime); free(rinv);
//free(willy);
}[/spoiler]

Lefordul, lefut, és a mért görbékhez hasonlókat produkál. Az a gond, hogy c-t és k-t nem tudom, épp azt szerettem volna megmérni...

[Solid Snake]

Sajnos jelenlegi állás szerint úgy tűnik, hogy Programozás alapjaiból nem kapok aláírást.
Írtam az ignoráns gyakorlatvezető tanárnak, hogy lesz-e aláíráspótlási alkalom. Majd elválik, hogy visszaír-e egyáltalán.

Azonban most a segítségeteket kérném: tudtok olyan szakirodalmat vagy netes tutorialt, ami tényleg emberi nyelven, érthetően, lépésről lépésre tanítja meg az embert a C nyelv alapvető programozási szintjére? Nem high tech anyagra van szükségem, inkább olyanra, ami ténylegesen az alapok alapját magyarázza el, egy kiindulópontot, ami hozzásegítene ahhoz, hogy aláíráspótláson (rosszabb esetben jövőre) "sikeresen" (vagyis a számomra megfelelő 2-essel) letudhassam ezt a tárgyat.

Előre is köszönöm, számítok rátok.

[kikuchiyo]

Kernighan&Ritchie könyv ("A" C könyv más néven)?

[spoiler]Brian W. Kernighan-Dennis Ritchie: A C programozási nyelv, Műszaki könyvkiadó[/spoiler]

Egyébként meg van egy csomó tutorial a neten. Igaz, nem ismerem őket, nem tudom, melyik jó.

[Xzone]

Sajnos jelenlegi állás szerint úgy tűnik, hogy Programozás alapjaiból nem kapok aláírást.
Írtam az ignoráns gyakorlatvezető tanárnak, hogy lesz-e aláíráspótlási alkalom. Majd elválik, hogy visszaír-e egyáltalán.

Azonban most a segítségeteket kérném: tudtok olyan szakirodalmat vagy netes tutorialt, ami tényleg emberi nyelven, érthetően, lépésről lépésre tanítja meg az embert a C nyelv alapvető programozási szintjére? Nem high tech anyagra van szükségem, inkább olyanra, ami ténylegesen az alapok alapját magyarázza el, egy kiindulópontot, ami hozzásegítene ahhoz, hogy aláíráspótláson (rosszabb esetben jövőre) "sikeresen" (vagyis a számomra megfelelő 2-essel) letudhassam ezt a tárgyat.

Előre is köszönöm, számítok rátok.

Ezek nekem elég jók voltak

A mi "A Programozás Alapjai" tárgyunk honlapja: http://www.eet.bme.hu/vieea100/
A gyakorlatvezetőm honlapja: http://www.hit.bme.hu/~szandi/prog1/index.htm

Jól le vannak írva az algoritmusok, példaprogramok ezeken az oldalakon szerintem.

Edit: A Kernignan & Ritchie könyv nekem megvan pdf-ben angolul, azt át tudom küldeni a ha szeretnéd.

[Solid Snake]

Brian W. Kernighan-Dennis Ritchie: A C programozási nyelv, Műszaki könyvkiadó

Azt vettem meg 2000 Ft-ért. Azt olvastam el kb. 150 oldalig. Attól ment fel leginkább az agyvizem a banális és túlontúl bonyolított magyarázatokkal.
Az én programozásra primitív agyam egyszerűen nem volt képes befogadni annak a könyvnek a tartalmát. 

[Próféta]

"ignoráns gyakorlatvezető" -> ?
ignoráns = tudatlan, de leginkább nem használjuk magyarul
biztos ezt a szót kerested?

Én sosem olvastam semmilyen C könyvet, az egyetemi előadás bőven elég volt az alapinformációk felszívására, a többi meg nem annyira tanulható könyvből (ebben pl. más a C++).
Ha sima C-ről van szó (tehát nem C++), akkor vagy megy "magadtól", vagy sehogy.
A "magadtól" természetesen nem úgy értendő, hogy úgy születsz.
A legfontosabb, hogy írj sok kódot. Otthon telepítsd fel kedvenc fordítódat és fejlesztőkörnyezetedet, és kezdj el C-ben kódolni, hibát keresni, megérteni, megtanulni, kijavítani, tovább kódolni. Masszívan.
Ha elég jól meg van szervezve a laborgyakorlat + házi feladat rendszer, az sokat segíthet; ha meg nem, akkor légy autodidakta (+ kérj segítséget havertól, tőlünk, stb. ha megakadsz).

És hamár Xzone szóba hozta Szandit, az oldaláról ajánlom ezt a linket: http://www.hit.bme.hu/~szandi/prog1/stdc.pdf
Ezt tök hasznos kinyomtatni egy lap két oldalára, és magaddal hordani / programozás közben az orrod előtt tartani. Nálunk ZH-n is szabad volt használni.
Ami rajta van a lapon, azt eszedbe ne jusson bemagolni.

[kikuchiyo]

Egy tanács SS-nek:

A hozzászólásaidból az jön le nekem, hogy utálod az egészet, a tököd tele van a programozással.
Ez nem jó, ilyen lelkiállapottal/hozzáállással nem lehet megtanulni.

Úgy lehet megtanulni, ha magad elkezdesz programokat írogatni. Nem kell a semmiből újraírni egy nap alatt a linux kernelt, kis vackokat is elég, amiken a nyelv épp megtanult feature-eit ki tudod próbálni. Pusztán könyvből nem lehet megtanulni, gyakorolni kell.

Persze tipikusan a programozás nem szórakoztató, amikor órákon keresztül nem érted, miért nem működik, pedig már minden sort átnéztél hatszor, aztán kiderül, hogy egy lényegtelennek látszó helyen >-t írtál >= helyett. De ha végül sikerül életre csiholni, az valamelyest sikerélményt jelent.

Persze én is csak fél-háromnegyed-(1-epszilon)-amatőr vagyok...

[Solid Snake]

Köszi a segítséget, igyekszem megfogadni a tanácsaitokat.

Ha sima C-ről van szó (tehát nem C++), akkor vagy megy "magadtól", vagy sehogy.
A "magadtól" természetesen nem úgy értendő, hogy úgy születsz.

Ebben mélyen egyetértek veled.
Bár a máig kedvenc tanárom, a középsulis töritanárnő azt mondta, hogy a programozásra születni kell.

A hozzászólásaidból az jön le nekem, hogy utálod az egészet, a tököd tele van a programozással.
Ez nem jó, ilyen lelkiállapottal/hozzáállással nem lehet megtanulni.

Igazad van. Mindig is gyűlöltem a programozást pontosan azért, mert nem egzakt tudományág. Az alapdolog megegyezik, az igazsághoz azonban több út vezet el, legoptimálisabb megoldás nem létezik, valóban az önállóságon múlik nagyrészt a dolog. Soha nem tudtam sikeresen programozni. Nem láttam át, hogy miért vannak úgy a dolgok egy-egy programban, ahogy. Nem vagyok programozó. Nem is az akarok lenni. Viszont sajnos van ilyen tantárgy is ezen a szakon, így hát akár akarom, akár nem, mindenképpen át kell mennem legalább 2-es érdemjeggyel.

[Darkstar]

aztán kiderül, hogy egy lényegtelennek látszó helyen >-t írtál >= helyett.

Engem inkább az idegesít fel, amikor valahol kimarad egy }, és nem tudok rájönni hogy hol...

[Manitu]

Azonban most a segítségeteket kérném: tudtok olyan szakirodalmat vagy netes tutorialt, ami tényleg emberi nyelven, érthetően, lépésről lépésre tanítja meg az embert a C nyelv alapvető programozási szintjére? Nem high tech anyagra van szükségem, inkább olyanra, ami ténylegesen az alapok alapját magyarázza el, egy kiindulópontot, ami hozzásegítene ahhoz, hogy aláíráspótláson (rosszabb esetben jövőre) "sikeresen" (vagyis a számomra megfelelő 2-essel) letudhassam ezt a tárgyat.

Ahogy már egy páran írták előttem, olvasgasd A C könyvet. Meg ott a help, ne félj nyomkodni az F1-et.

Persze tipikusan a programozás nem szórakoztató, amikor órákon keresztül nem érted, miért nem működik, pedig már minden sort átnéztél hatszor, aztán kiderül, hogy egy lényegtelennek látszó helyen >-t írtál >= helyett.

Ezek szerint csak én látok valamiféle perverz szépséget az ilyenekben?

[Próféta]

Engem inkább az idegesít fel, amikor valahol kimarad egy }, és nem tudok rájönni hogy hol...

PROTIP: zárójelet, kacsacsőrt, idézőjelet, szögletes dobozt mindig nyitó-csukó párral kell egyszerre létrehozni, és utána visszamászni és beírni a tartalmát. Úgy nem marad félbe.

Amúgy jobb IDE-k segítenek maguktól indentálni (behúzni) a szöveget, hogy feltűnőbb legyen, ill. ha ráállsz egy kapocsra, akkor megjelöli a párját, és mindjárt látod, ha nem stimmel a dolog.
De persze én is szeretek szövegszerkesztővel kódolni, parancssorból fordítani, mert az úgy vagányabb

[kikuchiyo]

Code Select Expand

$cat > code.c FTW

[Darkstar]

PROTIP: zárójelet, kacsacsőrt, idézőjelet, szögletes dobozt mindig nyitó-csukó párral kell egyszerre létrehozni, és utána visszamászni és beírni a tartalmát. Úgy nem marad félbe.

Úgy szoktam, de néha véletlen sikerül egyet véletlenül kitöröln, felülírni, etc, és akkor kezdődhet a játék.

[kikuchiyo]

Ha már programozásnál tartunk, találtam egy jó hacking manualt, arról, hogy hogyan kell kihasználni a puffertúlcsordulásokat és hasonlókat, talán érdekli a t. társaságot:
Not A Rickroll

[Próféta]

Code Select Expand

$cat > code.c

Code Select Expand

$hexedit a.out && chmod +x a.out
(Én régen komolyan azt hittem, így műxik a programozás. Persze akkor még nem tudtam, mi az a chmod.)

[Selmo]

XML-hez ért valaki? Jól látom, hogy nem lehet benne feltételt megadni?

[Próféta]

XML-hez ért valaki? Jól látom, hogy nem lehet benne feltételt megadni?

XML simán egy dokumentumfát (DOM) ír le, semmiféle időbeliség vagy logika nincs benne, még formázás se.
Esetleg XSLT-re gondoltál? Abban természetesen van xsl:if, xsl:choose, stb.
Vagy félreértelek? Tulajdonképpen mire akarod használni az XML-t?

[Selmo]

Nem, XML. Telepítési leíró lenne belőle és szükség lenne a kódolás lekérdezésére, hogy melyik fájlt másolja fel. De akkor erre marad a PHP vagy két telepítőcsomag.
Probléma megoldva, csak egy error="skip" kellett bele.

[chilip]

Code Select Expand


#include <iostream>

int main()
{
std::cout << "Hello world!" << std::endl;
return 0;
}



ehhez kéne egy lgraph.h-t írni, ti hogy csinálnátok?  és minnél hamarabb kéne, ha lehetséges cenzored