Code Block telepítése

Első program ami épp egy szöveget ír ki.

[ Szerkesztve ]

Hali!
Kellene egy eleg egyszeru adatnyilvantarto programot csinalnom. Annyit kell tudnia, hogy adatokat bekerni, listazni, modositani, torolni es a listazasnal elotte rendezni is kell a tombbot. Annyi meg a kikotes, hogy nem lehet strukturat es dinamukus memoriat hasznalni. A következot alkottam eddig: [link] Egy kis segitsegre lenne szuksemem vele kapcsolatban, a torles es buborekos rendezesnel nem tudom, hogy mit kellene kezdenem vele.

Valaszoakt elore is koszonom!

C != C++

Tömböt nem tudsz értékadó utasítással másolni.

char tmp1[100];
char nevek[max][100];

tmp1=nevek[j];

for ciklussal a tömb egyes elemeit másold a a másik tömb megfelelő elemei közé. (Szerk.: bamba voltam; használd a beépített stringkezelő fv-eket.)
Előtte olvasd át ezt.

[ Szerkesztve ]

C-ben a sztringek karaktertömbök, és azokat nem lehet csak úgy értékül adni egymásnak. Erre találták fel az strcpy függvényt. Tehát pl. ehelyett:

nevek[i]=nevek[i+1];

Ez fog kelleni:

strcpy(nevek[i], nevek[i+1]);

Tudom, tudom, akasszak a tökömre egy lámpát, hogy sötétben is tudjak kaszálni.

Most már elindul a program,a törlés része jó is, viszont mikor listáznám akkor leáll a program.
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#define max 100

int main () {
int azon[max];
char nevek[max][100];
int telszam[max];
int menu;
int db=0;
int i,j;
bool letezik;
bool kesz;
int a;
int keres;
char torol; //torles megerositesehez
int tmp;//ideiglenes buborekos rendezeshez
char tmp1[100];
printf("\t\t\t\t\tAdatnyilvantarto program: \n");
printf("Menupontok: \n");
Menupontok:
printf("Uj adat:(1), Kereses:(2), Adatmodositas:(3), Torles:(4), Listazas:(5), Kilepes:(6)\n");
printf("valasz: ");scanf("%d",&menu);
switch (menu) {
case 1:
printf("__________________________________\n");
printf("Uj adat felvetele\n");
do {
azon_bekeres:
printf("Adjon meg egy int tipusu azonositot: ");scanf("%d",&a);
for(int i=0;i<db;i++){
if(azon[I]==a) {
printf("Ez az azonosito mar szerepel! Adjon meg masikat!");
goto azon_bekeres;
letezik=1;[/I]

[I]}else {
letezik=0;
}
}
if (letezik==false) {
azon[db]=a;
printf("Adja meg a nevet: ");scanf("%s",&nevek[db]);
printf("Adja meg a telefonszamot: ");scanf("%d",&telszam[db]);
db++;
printf("Uj adat felvetel: (0), Menupontok: (1): ");scanf("%d",&kesz);
}
}while(kesz!=true);
goto Menupontok;
case 2:
printf("__________________________________\n");
printf("Kereses:\n");
printf("rekordok szama: %d\n",db);
printf("Adja meg a keresendo rekord azonositojat: ");scanf("%d",&keres);
i=0;
while(azon(i)!=keres) {
i++;
}
if (i==db+1) {
printf("Nem letezik rekord a megadott azonositoval!");
}else {
printf("Azonosito: %d - Nev: %s - Telefonszam: %d\n",azon(i),nevek(i),telszam(i));
}
goto Menupontok;
case 3:
printf("__________________________________\n");
printf("Adatmodositas:\n");
printf("Adja meg a modositando rekord azonositojat: ");scanf("%d",&keres);
i=0;
while(azon(i)!=keres) {
i++;
}
if (i==db+1) {
printf("Nem letezik rekord a megadott azonositoval!");
}else {
printf("Uj nev: ");scanf("%s",&nevek(i));
printf("Uj telefonszam: ");scanf("%d",&telszam(i));
}
printf("\nA modositas megtortent!\n");
goto Menupontok;
case 4:
printf("__________________________________\n");
printf("Rekord torlese:\n");
printf("Adja meg a torlendo rekord azonositojat: ");scanf("%d",&keres);
for(i=0;i<db;i++){
if(keres==azon(i))break;
}
if(db==i)printf("Nem létezik a megadott azonosito!");
else{
printf("Biztos torlni akarja a megadott rekordot? (%d - %s - %d)(1-Igen/0-Nem)",azon(i),nevek(i),telszam(i));scanf("%d",&torol);
if(torol==1) {
for(;i<db;i++){
strcpy(nevek(i), nevek[i+1]);
telszam(i)=telszam[i+1];[/I]

[I]}
}else {
break;
}
}
db--;
goto Menupontok;
case 5:
printf("__________________________________\n");
printf("Listazas:\n");
//Buborék rendezés
for(int i=0;i<db-1;i++) {
for(int j=0;db-i-1;j++) {
if(azon[j]<azon[j+1]) {
tmp=azon[j];
azon[j]=azon[j+1];
azon[j+1]=tmp;
strcpy(tmp1, nevek[j+1]);
strcpy(nevek[j], nevek[j+1]);
strcpy(nevek[j+1], tmp1);
tmp=telszam[j];
telszam[j]=telszam[j+1];
telszam[j+1]=tmp;[/I]

[I]}
}
}
printf("Azonostio - Nev - Telefonszam\n");
for(int i=0;i<db;i++) {
printf("%d - %s - %d\n",azon(i),nevek(i),telszam(i));[/I]

[I]}
goto Menupontok;
case 6:
break;
}
}[/I]

[I]A cserével lenne valami gond?[/I]

[ Szerkesztve ]

Code Blocks-ra esett a választásom. Bele is kerültem az első akadályba, program begépelése után nem írja ki a megfelelő sort, szerintem el sem indul , mert a "Build log"-ban ezt írja:

""Rookie3 - Debug": The compiler's setup (GNU GCC Compiler) is invalid, so Code:locks cannot find/run the compiler.
Probably the toolchain path within the compiler options is not setup correctly?! (Do you have a compiler installed?)
Goto "Settings->Compiler...->Global compiler settings->GNU GCC Compiler->Toolchain executables" and fix the compiler's setup.
Skipping...
Nothing to be done (all items are up-to-date).
"

Kérdésem az lenne, hogy mi kell még ahhoz, hogy elinduljon? Köszönöm a választ.

LEGO-ból bármit megépíteni, csak idő kérdése.

Ha egyszerűen akarsz működő eredményt, töröld le a mostani telepítésedet, és helyette a codeblocks-16.01mingw-setup.exe-t szedd le és telepítsd. Ebben benne van az a GCC fordító, amit hiányol.

“All nothings are not equal.”

Megtettem. Ugyanaz történt, mint eddig. Sőőőőt, olyannyira, hogy az előző is 16.01-es volt.

[ Szerkesztve ]

LEGO-ból bármit megépíteni, csak idő kérdése.

Akkor manuálisan kell beállítanod a toolchain-t.

Settings menu -> compiler menüpont -> Toolchain executables fül

Felül válaszd ki a GNU GCC Compiler-t
A legfelső szöveges mezőbe, add meg a Mingw gyökérkönyvtárát.
Majd ellenőrizd le, hogy az alatta található exe-k megtalálhatóak a mingw\bin könyvtárban (kétfajta mingw van és a C/C++ compiler exe-jének a neve eltér)

Szoktam, csak ez a beillesztés most nem jött össze.

1)
char * strcpy ( char * destination, const char * source );
Paraméterek sorrendjére ügyelj. Így a csere így néz ki:

strcpy(tmp1, nevek[j]);
strcpy(nevek[j], nevek[j+1]);
strcpy(nevek[j+1], tmp1);

2) for ciklus feltétele rossz volt. A második részt nézd meg.
for(int j=0; db-i-1; j++) helyen inkább
for(int j=0; j<db-i-1; j++)

Emlékeim szerint a kompájlerrel egybecsomagolt CodeBlocks-ot nem kell tovább konfigurálni, hanem egyből érzékeli a mellé adott gcc-t.Biztosan jó volt a telepítésed?

Egybként a CB+GCC kombót nem feltétlenül ajánlanám olyan kezdőnek, aki Excel-be akarta írni a printf() -et.Ha Windows-on programozol akkor a PellesC vagy az MS Visual Studio barátibb környezetet biztosít.

Telepítés során semmilyen anomáliát nem véltem felfedezni.Természetesen nem akarom beírni az MSExcel-be beírni, sőt a böngészőbe sem a printf()et. Sajnos a profi többség SOSEM segít az érdeklődő kezdőknek, néhány kivételtől eltekintve.

LEGO-ból bármit megépíteni, csak idő kérdése.

Köszönöm a segítséget! Nem tudom hogy nem vettem észre.

Mindent a leírtaknak ellenőriztem és ehhez képest nem találtam különbséget.

LEGO-ból bármit megépíteni, csak idő kérdése.

Gyakran jönnek ide (és nyilván más hasonló fórumokra is) olyan emberek, akik a tökéletesen nulla szintről (lásd: hová írjam a printf()-t) szeretnének megtanulni programozni és ezt úgy képzelik, hogy majd itt sorról sorra elmagyarázzák nekik a profik. Ez nem működik. Csak akkor tudunk segíteni, ha már legalább az olyan alapfogalmakkal tisztában vagy, mint forráskód, fordító, változó, stb. - és ezt nem lehet kérdezz-felelek formában elsajátítani.

Itt van egy teljesen kezdőknek készített C tutorial (environment setup, basic syntax, stb.), innen el tudsz indulni, és ha valahol elakadtál, biztosan lesz valaki ebben a topikban, aki segíteni fog:

https://www.tutorialspoint.com/cprogramming/index.htm

[ Szerkesztve ]

Köszönöm! Nem is azzal van a probléma, mint kezdő, de nem a nulláról kezdő (nem írom le, hogy mi a munkám, de ilyen jellegű programozással először találkozom), hogy hová írjam, azt sok helyen leírják pl. könyvben ,és nem is a tutorial-lal van a gond, hanem mivel írjam oda, ahová kell! Ez volt az első kérdésem. Sajnos, akik válaszoltak itt éppen efölött siklottak el, persze később ez javításra került. Amint sikerül feltelepítenem és normálisan használatba vennem az adott programot, jöhet a link és a tutorial.

LEGO-ból bármit megépíteni, csak idő kérdése.

Igaz, hogy a .exe-k ugyanazok voltak, de egyesével kiválasztottam mindet. És hoppáááááá, helyreállt a világ. Első sikerélmény, köszönöm a segítséget. Üdv.: Joe

LEGO-ból bármit megépíteni, csak idő kérdése.

A fenti oktatóanyagban az Environment Setup pontban részletesen leírja a telepítést, linkelve a mingw honlapját is.

Ismét előjött az eredeti problémám, de valószínűleg formai hiba miatt, mert készítettem egy újat és minden működött. No, most már jöhet a programozás, aztán a mikrokontroller.

LEGO-ból bármit megépíteni, csak idő kérdése.

Üdv.
Vajon mi lehet a baj? NEm tudok rájönni

struct partition{
char *path;
char *mount;
char *opt;
char *num1;
char *num2;
} ;
...
struct partition p;
...

pch = strtok (fstab," ");
int j=0;
while (pch != NULL)
{
switch (j)
​ 46. sor {
case 0:
printf("asd");
p.path=pch;
break;
case 1:
p.mount=pch;
break;
case 2:
p.opt=pch;
break;
case 3:
p.num1=pch;
break;
case 4:
p.num2=pch;
break;

}

pch = strtok (NULL, " ");
j++;
}

g++ split.c && ./a.out
split.c:46:1: error: stray ‘\342’ in program
��� {
^
split.c:46:2: error: stray ‘\200’ in program
��� {
^
split.c:46:3: error: stray ‘\213’ in program
���

[ Szerkesztve ]

A bus station is where a bus stops. A train station is where a train stops. On my desk, I have a work station

ASCII karakterkódolást használj.
Gondolom valamit kimásoltál a böngészőből, és egy nyomtathatatlan/láthatatlan karakter bennmaradt.

[ Szerkesztve ]

Üdv.

Sajnos nem vagyok teljesen képben a memóriakezeléssel. Egy kis segítségre lenne szükségem.
Pastebin

Létrehoztam egy struktúrát amiben char * mutatók vannak.
Ebből létrehoztam egy tömböt.(később ezt is át akarom írni dinamikusra) Majd egy ciklusban az összes struktúra elemet mallocolom. és értéket adok neki.

A problémám az hogy a cikluson belül amikor értéket adok a struktúra elemeinek akkor azok kiolvashatóak belőle. De amikor az egész struktúrát iratnám ki akkor Minden érték NULL

Mit csinálok rosszul?

[ Szerkesztve ]

A bus station is where a bus stops. A train station is where a train stops. On my desk, I have a work station

Úgy látom nagy a baj! Nem csak a memória kezeléssel, hanem úgy általában. Az fstab egy 1 byte (karakter mérete) hosszú memória terület kezdőcíme.
fstab[i-1]=='\n'
Ez mi? Inicializálatlanul használod az fstab memória területet, ráadásul rögtön -1 indexszel, ami egyébként is a lefoglalt memória területen kívül esik. Mivel nem írsz rá, hanem csak olvasod, jó eséllyel nem akad ki a program azonnal, de akár az is előfordulhat.
Szerintem előbb gondold át mit is akarsz csinálni, mert nem csak a C nyelvvel állsz hadilábon. Ha lesz időm, válaszolok bővebben is.

„Kétségtelen, hogy nem tudjuk, mit tegyünk, de felkészültek és elszántak vagyunk.” - Olaf Scholz német kancellár

Köszönöm a választ.
Igen, rátapintottál a lényegre, eléggé hadilábon állok a c-vel. De valahol el kell kezdenem.
Linux Fstab-ját szeretném dekódolni, egy struktúrába,
A tömbindex túllépést már kiküszöböltem. Hozzászoktam hogy az eclipse egyből sír ilyenkor.
if(tmp == '#') boole=1;
if(boole==1 && tmp!='\n') continue;
if(boole==1 && tmp=='\n') {boole=0; continue;}

[ Szerkesztve ]

A bus station is where a bus stops. A train station is where a train stops. On my desk, I have a work station

Tipp:
Ha a boole valtozot csak logikai ertekek tarolasara haszanlod, akkor folosleges az ==1 vizsgalat. A nem 0 int az mindig igazra ertekelodik ki. Ha ott van egy redundans ertekvizsgalat, akkor az sokaknak megteveszto lehet.
Hogy olvashatobb legyen a kod, definialhatsz egy sajat tipust az intre amit logikaikent hasznalsz es tovabbi 2 konstanst az igazra es hamisra (pl.: 1, 0). Onnantol hasonlokepp hasznalhatod oket, mint a magasabb nyelvekben. Vagy ha nagyon kenyelmes vagy, akkor include-olhatod az stdbool.h-t ami lenyegeben az iment leirtakat tartalmazza.

[ Szerkesztve ]

Gender of electrical connectors is defined by the pins.

Sziasztok!

Mikrovezérlőben van egy delay függvényünk, ami asm-ben van írva és azt használjuk késleltetésre. Ez a függvény jól működik, viszont ha USB-t is használunk akkor a GCC O3-as optimalizációjával vagy bekapcsolt LTO-val nem jön létre az USB eszköz, míg minden más beállításban igen és jól is működik.

Azt gyanítjuk, hogy az O3 optimalizálás csinál valamit ezzel az asm kóddal és az időzítés nem lesz kellően pontos, arra pedig érzékeny az USB.

__attribute __((naked))
void delay_loop (unsigned n)
{
__asm volatile ("1: sub r0, #1");
__asm volatile (" bne 1b");
__asm volatile (" bx 1r");
}

Szerintetek?

Nincs más - csak egy szál gitár - szidom a rendszert - forradalmár. - Én vagyok egyedül 88 telén. (Auróra)

Szerintem én első körben megnézném, hogy mit fordít belőle a gcc:
gcc -S -O3 delay.c

DRM is theft

Én már láttam ilyen compiler hibát x86->arm crosscompilernél, hogy -O3 esetén "túloptimalizált" (értsd: elb@szott) valamit, szóval mindenképp nézzétek meg az assemblyt, mert lehet, hogy egyszerűen hibás.

[ Szerkesztve ]

Same rules apply!

Az attribute-os sort picit más formában kellett megadnom __attribute__ ((naked)), de a GCC és a none-eabi arm-es gcc is ugyanazt fordítja a különböző opt. módokban, beteszi ami ott áll.

.cpu arm7tdmi
.fpu softvfp
.eabi_attribute 20, 1
.eabi_attribute 21, 1
.eabi_attribute 23, 3
.eabi_attribute 24, 1
.eabi_attribute 25, 1
.eabi_attribute 26, 1
.eabi_attribute 30, 6
.eabi_attribute 34, 0
.eabi_attribute 18, 4
.file "delac.c"
.text
.align 2
.global delay_loop
.type delay_loop, %function
delay_loop:
@ Function supports interworking.
@ Naked Function: prologue and epilogue provided by programmer.
@ args = 0, pretend = 0, frame = 0
@ frame_needed = 1, uses_anonymous_args = 0
@ 4 "delac.c" 1
1: sub r0, #1
@ 0 "" 2
@ 5 "delac.c" 1
bne 1b
@ 0 "" 2
@ 6 "delac.c" 1
bx 1r
@ 0 "" 2
.size delay_loop, .-delay_loop
.ident "GCC: (4.9.2-10+14~bpo8+1) 4.9.2"

Hasonló a sima GCC kimenete is. Annyit még tudok mondani, hogy GCC4.8, 4.9 és 5.x alatt is azonos a helyzet azon a gépen, ahol dolgozom.

EQMontoya: kellene valaki, aki ért hozzá.

[ Szerkesztve ]

Nincs más - csak egy szál gitár - szidom a rendszert - forradalmár. - Én vagyok egyedül 88 telén. (Auróra)

Biztos, hogy itt van a hiba és nem máshol? Gondolom az egész kódot O3-ban fordítod.

Csak tapogatózunk. Annyit tudunk, hogy a port inicializálásakor egy nagyon pontos idejű delaynek kell ott lennie, mert különben a pc nem látja. Ezen a lenti kódon egyszer kellett módosítani, mikor átváltottunk a SourceryG++ fordítóról GCC-re. Azonos beállítások mellett a GCC-s kóddal nem működött az usb. Azt hiszem meg kellett növelni az egyik értéket egyel.

Nem lenne gond a csak O2 használata, mert az O3-as optimalizáció már kódméret növekedéssel is jár, de az LTO is megöli az usb-t, miközben elég impresszív kódméret csökkentést lehet vele elérni.

Ha lesz kis időm ezzel a viszonylag sürgős munkával, akkor majd végignézem egyenként azt a pár kapcsolót, amit az O3 hoz be, hogy melyiknél hal meg az usb.

Nincs más - csak egy szál gitár - szidom a rendszert - forradalmár. - Én vagyok egyedül 88 telén. (Auróra)

Vagy esetleg azt is lehet, hogy a delayes részt kirakni egy külön .c file-ba és azt O2-vel fordítani, a tobbi meg mehet O3-mal.

DRM is theft

Nem rossz gondolat, csak nem tudom miként lehet ezt megcsinálni a CooCox ide-ben.

stepboy: jó ötlet!

Amúgy sokfelé van hívva, ez minden időzítésnek az alapja. Az inlineolás jó kérdés, ahogy olvastam a gcc doksikat, azt O2-nél már magától csinálja, valamilyen logika alapján, független a kézi inline deklarálástól.

[ Szerkesztve ]

Nincs más - csak egy szál gitár - szidom a rendszert - forradalmár. - Én vagyok egyedül 88 telén. (Auróra)

Ha van egy szabad portod, akkor tudnál port billegtetést csinálni és kívülről vizsgálni, hogy valóban annyi idő telik-e el mint amennyire számítasz:

port_fel;
delay();
port_le;

ezt megnézni O2-vel, O3-mal meg LTO-val. Ha igen, akkor nem ezzel a függvénnyel lesz baj.

Nem tudom, lehet, hogy hülyeség - esetleg, nem inline-olja a függvényt és cseszi el a regisztereket az O3/LTO build? Sok helyről hívjátok ezt a függvényt? Ha nem, akkor gyorsan meg lehetne nézni azokat a területeket is egy disassemblyvel.

[ Szerkesztve ]

esetleg, próbáld ki ezt:
http://stackoverflow.com/questions/12114019/g-and-attribute-optimize-not-changing-debugger-behavior

itt azt írja, hogy alapból O2-vel fordít, de egy függvényt ezzel az attribute-tal máshogy tud optimalizálni.

#include <iostream>
#include <vector>

int MyNormalFunction();

int MyDebugabbleFunction() __attribute__((optimize(0)));

int MyNormalFunction()
{
int val = 0; // breakpoint here - debugger does NOT stop here
val = 1;
val = 2;
return val;
} // debugger stops here instead

int MyDebugabbleFunction()
{
int val = 0; // breakpoint here - debugger stops here and steps through the next 3 lines as if it were built with only -g
val = 1;
val = 2;
return val;
}

int main()
{
int a = MyNormalFunction();
std::cout << a << std::endl;

int b = MyDebugabbleFunction();
std::cout << b << std::endl;

return 0;
}

Megpróbáltam, érdekes módon nem sikerült megtalálnom azt a részt, ami a gondot okozza. Se a delay, se az usb-s függvények O0-ra állított optimalizálása nem okozott eltérést. Majd még vizsgálódok tovább.

Nincs más - csak egy szál gitár - szidom a rendszert - forradalmár. - Én vagyok egyedül 88 telén. (Auróra)

Valószínű, hogy máshol van a hiba, ami kihatással van az USB működésére. A projekt többi része működik/meg lehet állapítani, hogy működik?

Viszont a kódot biztosan rossz:
__attribute __((naked))
void delay_loop (unsigned n)
{
__asm volatile ("1: sub r0, #1");
__asm volatile (" bne 1b");
__asm volatile (" bx 1r");
}

[Itt találod a GCC Basic Asm leírását]

Van benne néhány fontos megjegyzés:
Do not expect a sequence of asm statements to remain perfectly consecutive after compilation. If certain instructions need to remain consecutive in the output, put them in a single multi-instruction asm statement. Note that GCC’s optimizers can move asm statements relative to other code, including across jumps.

vagy ezek:
GCC does not parse basic asm’s AssemblerInstructions, which means there is no way to communicate to the compiler what is happening inside them. GCC has no visibility of symbols in the asm and may discard them as unreferenced. It also does not know about side effects of the assembler code, such as modifications to memory or registers. Unlike some compilers, GCC assumes that no changes to general purpose registers occur. This assumption may change in a future release.

For basic asm with non-empty assembler string GCC assumes the assembler block does not change any general purpose registers, but it may read or write any globally accessible variable.

Megnéztem az optimalizációs leírást is, O3-mal jön az inline valóban, de azt ki lehet kapcsolni "noinline" attribute-tal (bár ez egy jó régi GCC: 4.7.4).

Ami a megjegyzéseket illeti, az elsőt nem hiszem, hogy vonatkozik rád a volatile miatt, tehát a sorrend marad. Viszont az inline miatt előfordulhat, hogy nem az van az R0-ban, amire számítasz. Normál esetben a függvényhíváskor az első paraméter valóban oda kell, hogy kerüljön, de ha a függvényt inline-olja a fordító, akkor már nincs garantálva, hogy az R0-án keresztül ad át bármit is, mivel a fordító nem látja, hogy bármi is történik az "n" változóval és azt feltételezi, hogy a regisztereket nem módosítja az assembly kódod.

Azt gondolom, hogyha már mindenképpen beágyazott assembly-t akarsz írni, akkor azt valahogy így kéne csinálni:

void delay_loop (unsigned n)
{
__asm ("1: sub %0, #1 \n\t"
" bne 1b \n\t"
" bx 1r "
:
: "r" (n));
}

Mindezt az Extended-Asm leírás alapján (a fenti link következő oldala); itt már jelzed a fordítónak, hogy egy regisztert biztosan használsz és minden egy helyen van, ezért nem változhat meg a sorrend.

Bár a legjobb mindenképpen az lenne, ha az egészet átrakod sima assemblyre és akkor a fordító számára egy függvényhívás lesz a kód, amivel már nem tud trükközni.

[ Szerkesztve ]

Hali!
Kaptam egy olyan házi feladatot, hogy egy korábbi adatnyilvántartó programomat kell átírnom úgy hogy rekordok tárolásához struktúrát használjak, és mindenhez függvényt kell. Ez meg is van viszont a problémám az, hogy a keresés, és módosítás rész sehogy sem akar össze jönni, vagyis ha olyan azonosítóra keresek ami nem létezik akkor vagy kifagy a program vagy pedig csak kiír valamit ami egyébként nincs benne. Próbáltam már több módot, a törlés részből másoltam akkor sem volt jó szóval nem nagyon tudok vele már mit kezdeni.

más: Az miért van, hogy a code::blocks rendesen megjeleníti ahogy elterveztem, viszont nem működik a program? ez alatt azt értem, hogy amikor új adatot akarok megadni akkor folyamat csak új azonosítót kér, a devC++ meg fordítva.

Szerintem a keresesnel csak siman tulfutsz az i indexeddel. Ha a programodban mindig pontosan db szamu rekordod van, akkor a kereses ciklusaban nem i<=db lesz a megallas, hanem i < db. Elso korben ezt nezd meg.

Gender of electrical connectors is defined by the pins.

Próbáltam azt is, de akkor kifagy.

Az adatmodositas fuggvenyben sem nez ki ez olyan jol:
while(n[i].azon!=keres) {
i++;
}
mi van ha olyan azonositot adok meg, ami nem letezik? Azt latom hogy mogotte raellenorzol hogy nem futott-e tul az index, de ha egyszer tulfut, akkor bennragad ebben a ciklusben. Vagy sigsegv-vel kivag... Kellene valami ellenorzes i-re is.

Progteteleket nem tanitanak nektek?

[ Szerkesztve ]

Gender of electrical connectors is defined by the pins.

Beraktam ciklusba feltételnek az i<db-ot de most is kifagy nem létező adatnál. Nem a legjobb tanárt kaptuk meg a suliban.

Ha feltételt vizsgálsz, akkor a te esetedben if (letezik==false) helyett írhatnál if (!letezik), true-nál meg értelemszerűen nem kell a !, ez csak egy tipp.
Lefordítottam a kódot és nekem tele volt errorral. C99-es szabványt nekem nem fordítja le a compilerom for(int i=0;....) miatt. Illetve még a struktúrából létrehozott példányt sem fogadta el. Ezt a javítást kellett megcsinálnom. typedef struct nevek{......}nevek;
Ezek után letudtam fordítani a kódot hiba nélkül, és nekem teljesen jól működik, egyedül az a nem jó, hogy a db változónak 0-át adsz mert így csak az azonosítókat kéri be. Ezt javítsd ki valahogy.

Értem, köszönöm!

Hmm, annyi minden feldolgozni való tudás!

Az assembly kódhoz ugyan nem értek, de kipróbáltam a te verziódat is, és azzal is ugyanazt tapasztaltam. Lehet majd nemsokára megpróbálom azt, hogy függvényenként külön bekapcsolom az O3-as optimalizálást, hátha úgy kibukik a gondunk forrása.

Nincs más - csak egy szál gitár - szidom a rendszert - forradalmár. - Én vagyok egyedül 88 telén. (Auróra)

Remélem nem túl nagy a kód, különben elég nagy szívás függvényenként végigmenni.
Hátha ez egy kis segítség lehet: Options That Control Optimization