[c++]malo pozabljene osnove ali drugačen način v linux?

rajsi primerjaj z kakim string compare ... ala strcmp( ... ) == 0 > potem je enak :)

Namesto if ( argv[1] == NULL )
raje poglej argc. Ponavadi je le-ta 1 (ker imamo v argv[0] ime), ce je
2 pa tudi argv[1] ni NULL.

Aja za parsanje command line parametrov obstaja veliko boljsi nacin kot rocno preverjanje argv.
man 3 getopt

Če je argc 1, potem je v argv[0] ime programa. Če je argc 2, potem je v argv[1] prvi parameter.

seg fault sem dobival to je res
ampak ne zaradi tega
to je pa bil drug problem ki sem ga pa rešil...
za enkrat še pa nisem mel tega problema pri tem if stavku
bom pa spremenil da slučajno nebi prišlo do tega problema

in tudi if stavke bom pustil ker mam klobaso if stavkov in bom zamenjal z switch kar bi bilo bolj pametno...ali pač?

> in tudi if stavke bom pustil ker mam klobaso if stavkov in bom zamenjal z switch kar bi bilo bolj pametno...ali pač?
Tko bom reku, to je C++, če imaš klobaso kakršnihkoli stavkov, potem delaš nekaj narobe. Klobase if-ov in predolgi switch-i - to se da rešit objektno, s callbacki, pa še kako. Ampak to magari pusti tako kot maš ali spremeni tako, kot se boš bolje znašel. Bolj pomembno je, da poslušaš nasvete, ki si jih dobil, saj to, da nisi dobil segfaulta lahko pripišeš le svoji prekomerni sreči (če ga nisi dobil, še ne spremeni dejstva, da delaš nekaj narobe).

ok sem to zdaj malo spremenil
bom pa še podal eno vprašanje kar tukaj čeprav nima dosti veze z tem zgoraj kar je
ampak se mi ne da odpirat nove teme

torej, mam en class ustvarjen
in v tem classu je ena public char* funkicja
ki jo kličem iz main, ta funkcija pa mi vrne en string velikosti 8 znakov tipa private char str[7]
nikoli več, nikoli manj...vsaj tak bi moralo biti
ok manj res ni nikoli
torej mam v main:

classname variable;
cout << variable.funkcija() << endl;

vse lepo in prav ampak včasih(zelo pogosto) pripiše kar nek char
ali je to ?, % karkoli, glavno neki znakec mi pripiše zraven
tudi če v main deklariram še en char variable ime npr. var2
in potem kličem funkcijo tako

var2 = variable.funkcija();
ali:
strcpy(var2,variable.funkcija());

je popolnoma enako

kako lahko rešim tole zadevico?

edit: pozabil omenit, v funkciji se pa spremenljivka tipa private char str[7] lepo postavi na osem znakov, torej "12345678"
le ko jo kličem iz main se tist znakec prikrade zraven in vedno samo en in nič več

saj pravim da sem sprobaval več variant kako bi rešil, nobena iz moje glave ni bila uspešna

a se ne šteje 0 1 2 3 ... 7 torej to je 8 + 1 za \0 in bi blo char[7] čisto dovolj za 8 znakcev, če odmislim \0
vsaj tak so nam povedali v srednji šoli v drugem letniku...

tip[velikost] v C in C++ vedno deklarira polje velikost "velikost" elementov, z prvim indeksom 0 in zadnjim indeksom velikost-1. Velikokrat, kar nikakor ne velja samo za polja tipa char, pa se na uporabi vrednost 0 (pri številih) ali pa vrednost NULL (pri kazalcih), s katero se označi konec niza, katerega dolžina znotraj polja vnaprej ni znana. Ker se to vrednost zapiše znotraj samega polja, to pomeni, da imamo za niz tako na voljo en znak manj, kot pa je definirana velikost polja. Kar začetnike v tem C-ju velikokrat zmede, je obstoj celega kupa str* funkcij, ki dajo občutek, da je "string" nek dejansko definiran tip. V resnici pa so to samo pomožne funkcije za polja tipa char, v katerih se nahajajo nizi, ki se zaključujejo z vrednostjo 0 (oziroma znakom '\0').

Druga, pogosta napaka, ki jo začetniki naredijo, pa je napačno vračanje polja iz fukncije. Tukaj se lahko zelo hitro pripeti cel kup napak, zaradi nerazumevanja dejanskega delovanja kopice, sklada in prenosa parametrov. Tako lahko metoda vedno vrne char* (kar lahko zapišeš tudi kot char[]), vendar pa mora takšno polje tudi nekje obstajati. Če ga vračaš iz sklada metode, potem bo pri naslednjem klicu katere koli druge metode, ki uporablja parametere, ali pa lokalne spremenljivke, vsebina takšnega polja uničena. Natančno tako, kot se to zgodi tebi. Ker tako ugotoviš, da ne moreš vračati lokalne spremenljivke, si pač izbereš možnost, da boš polje naredil z "malloc" na kopici, namesto na skladu kot lokalno spremenljivko. Seveda pa je zabave konec tisti trenutek, ko ugotoviš, da delaš vedno nova in nova polja na kopici, nikoli pa jih ne sprostiš z "free". Če bo tvoj program deloval dovolj časa, boš zagledal "Out of memory", oziroma bo OOM na Linuxu ubil tvoj proces. Če pa tvoj program ne bo deloval dovolj dolgo, pa bo še vedno "nehigienično" napisan. Če si nenatančen pri takšnih "malenkostih", potem boš nenatančen tudi pri zadevah, ki bodo daleč od malenkostnih.

Sedaj imaš za vračanje polja iz funkcije še dve poti: v C-ju imaš (statično) rezerviran en sam globalen blok pomnilnika na kopici, ki ga "recikliraš". Pri zaporednih klicih funkcije prepišeš star rezultat, kar včasih je problem, včasih pa ni. Veliko str* funkcij iz standardne C knjižnice počne ravno to. Potem imaš pa čisti C++ način: uporabiš razred string, ki te reši vsega poslovodsta okoli pomnilnika, hkrati pa čisto pravilno deluje z cout objektom.

To je pa tudi vse, kar je... poglej si kaj je (sistemski) sklad in kako deluje. Pri golem C-ju je še posebej pomembno, da razumeš kako se prenašajo parametri med metodami in kako so shranjene lokalne spremenljivke. Ko boš znal to, boš tudi razumel kakšna je razlika med "char* foo" in "char[100] foo". Še posebej glede tega, kje se nahajajo elementi tako deklariranih polj. Ravno tako pa ne bo odveč, če si pogledaš še kakšno knjigo o C++, kjer boš ugotovil zakaj so objekti "dobra stvar" in na koliko različnih načinov lahko uporabiš že obstoječe.

IMO si zagrešil tri napake, ki so tako osnovne osnove, da dvomim, da si C ali C++ kdaj zares uporabljal. Zaradi tega sem odgovoril, kot pač odgovorim začetniku, ki še ni naredil domače naloge (knjige in Google).

Nimam se želje kregati, samo na kratko sem želel pojasniti zakaj je bil odgovor takšen, kot je pač bil. Tudi ne kot opravičilo, temveč samo pojasnilo. Tri osnovne osnove, ki so mi padle v oči, pa so bile:
- argv[1] == NULL, brez preverjanja velikosti polja (argc)
- argv[1] == "-h"
- "čudni znaki" na koncu izpisanega niza (nizi terminirani z '\0')

To ne pomeni, da ne znaš napisati programa v kakšnem drugem programskem jeziku. To samo pomeni, da jaz osebno (še vedno) dvomim, da si kadarkoli prej karkoli napisal v C/C++. Vsekakor pa menim, da mora vsak, ki želi resno programirati, spoznati tudi C (po želji pa še C++), saj je potrebno za njegovo optimalno uporabo vedeti veliko zadev, ki so drugje morda samo omenjene, kot zanimivost, ali pa teorija. Morda ne zato, da ga bo vsak dan uporabljal, temveč predvsem zato, ker se pri njemu hočeš nočeš naučiš večine zakonitosti delovanja današnjih računalnikov.

Če bi pa trdil karkoli več od tega, pa bi lakho že sprožil kakšno sveto vojno

- Za razčlenjevanje parametrov v ukazni vrstici ti toplo priporočam TCLAP in čim manj izumljanja tople vode.
- Kar se tiče build sistema sem pred nekaj časa preklopil iz GNU autotools na cmake.

Kar se mene tiče TCLAP.