Do while a podmínka s nebo – C / C++ – Fórum – Programujte.com

Zdravim,

zkoušela jsem z dlouhé chvíle vylepšit program tak, aby si uživatel nemohl zadat co chtěl, ale jenom vybraná čísla (viz kód) bohužel pokud použiji || v podmínce, vždycky se program zacyklí, na zadané správné hodnoty nereaguje, už vážně nevím....................

do 
{
cout << endl << "Zadejte cislo barvy, kterou chcete pouzit a to barvu c. 1, 3, 7, 19 nebo 25:";
cin >> barva;
} while (barva != 1 || barva != 3 || ...); // (barva != 1 || 3 || ...) tez nefunguje

Skus so tam dosadiť hodnoty a uvidíš kde máš chybu.  (ma tam byť and miesto or-u) 

máš namysli toto? 

while (barva != 1 && 3 && 7 && 19 && 25);

pokud ano, není to funkční.. nebo kam přesně dosadit hodnoty?

while (barva != 1 && 3 && 7 && 19 && 25);
//mozes prepisat takto:
while( (barva != 1) && true && true && true && true );
//a to zas takto:
while( barva != 1);

možná si trochu nerozumíme.. anebo pořádně nechápu, jak pracovat v tomto případě s true(jsem začátečník..)... do while nelze dát || nebo &&?

Hociake celé čislo ktoré sa nerovná 0 sa rovná true a 0 sa rovná false.

&& je logický AND a || je logický OR. viac tu http://www.cplusplus.com/doc/boolean/  (su to síce binarne operacie, ale tie tabulky platia aj pre tento prípad). AND a OR maju nižšiu prioritu ako  == a != .

tak už mi to jede následovně 

while ((barva != 1) && (barva != 3) && (barva != 7) && (barva != 19) && (barva != 25));

#7 delicacyy
spíš bych doporučil jiný řešení.. pokud těch barev bude hodně, tak je nesmysl mít tak "brutální" podmínku, ale udělat to stylem seznamu barev.. např. pomocí klasickýho pole stringů 

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

bool existsColor(string color, string colors[])
{
	for (int i = 0; i < sizeof(colors); i++)
	{
		if (*(colors + i) == color)
			return true;
	}
	return false;
}

int main()
{
	string barvy[] = { "1", "3", "7", "19", "25" };
	string barva;

	do 
	{
		cout << "Zadejte cislo barvy, kterou chcete pouzit a to barvu c. 1, 3, 7, 19 nebo 25:";
		cin >> barva;
	}
	while (!existsColor(barva, barvy));

	cout << "Vybrali jste barvu: " << barva;

	fflush(stdin);
	cin.get();
	return 0;
}

#8 ingiraxo
v tom se bohužel moc nevyznám díky svým chudším základním znalostem.. ale třeba časem :)

#1 delicacyy
nevím jak v C++ ale v C nemusís mít u stejných operátorů zavorky tudiž 

a == b && c == d && q == p // je v poradku
// stejne jako

a == b || c == d || q == p

tudíž bude asi chyba jinde nebo zkus použít závorky ale tím to asi nebude to pochybuju

#10 Atheo
aha až teď čtu odpovědi :D tak to bylo těma závorkama :D

#8 ingiraxo
ještě bych dodal že se to vůbec nemusí dělat takovým "brutal forcem" xD stačí : 

vstup barva = a;
barva(a);

void barva(int color)
{

........
}

Like a Atheo.

http://www.devbook.cz/…rvy-tutorial

||

http://www.devbook.cz/…rvy-tutorial

#12 Atheo
a kde si vzal, že se tady jedná o barvy textu v konzoli...

#13 ingiraxo
nevím celý to nikdy nečtu zbytečnost i kdyby to byla barva handle okna tak to funguje stejně akorát jinej kód ve funkci ^^ takže don't QQ

#14 Atheo
ale tady NEJDE o barvu textu v konzoli, já nevim proč to sem furt cpeš :-D pokud by to bylo tak, tak samozřejmě stací blbá funkce se switchem

přístě si zkus přečíst více toho zadání a né nadpis, zbytečně tu spamuješ :P

a problém rozhodně nebyl v závorkách v podmínce, ty být nemusí ani v C (v tomto případě, kde všude je buď and nebo or)

#15 ingiraxo

do 
{
cout << endl << "Zadejte cislo barvy, kterou chcete pouzit a to barvu c. 1, 3, 7, 19 nebo 25:"; // vstup nejaky cislo "barva"
cin >> barva; // promenna barva
} while (barva != 1 || barva != 3 || ...); // pokud je barva tohle a tohle ... bla bla

to znamená že to načte nějakou proměnnou barva :) a to se dostáváme k té mojí funkci ^^ tak nevím co tady pořád meleš

#16 Atheo
já řešil ale to, když těch hodnot barev bude treba (přeženu) 100, tak dělat 100x takový porovnání je lehce mimo, takže je mnohem jednodušší udělat seznam povolených barev a ty porovnávat se vstupem - viz. můj kód

ty s tvou tvoji funkcí máš pouze jeden parametr, kde opravdu nevim co tam chces s čim porovnávat, opět by jsi musel mít 100 podmínek, aby funkce mohla mít 1 parametr a vrátit boola ^^

já když něco dělám, tak vždy myslim na to, když toho bude hodně, aby to bylo efektivní nějak... a tady bylo zadání takový, že jednoduše chce jen porovnat vstupní hodnoty pro těch X barev/čísel

#17 ingiraxo
proto tam žádný porovnání bejt nemusí a stačí funkce ty primitive

"já řešil ale to, když těch hodnot barev bude treba (přeženu) 100, tak dělat 100x takový porovnání je lehce mimo, takže je mnohem jednodušší udělat seznam povolených barev a ty porovnávat se vstupem - viz. můj kód"

= ve funkci je to mnohem efektivnější a přehlednější 

kdyby těch barev bylo 50000000000000000000 tak se to napíše do funkce do jiného souboru a napíše se jen

funkce(proměnná)  tak už prosím tě drž pec meleš slušný hovna :D přes  funkci by to bylo XXXX* efektivnější/přehlednější než ten tvůj kód

#17 ingiraxo

nehledě na to že si pořád myslíš že do funkce chci cpát nějaký zvěrstvo jako jsou podmínky like a 

neco == neco || neco != neco neco == neco || neco 

a podobně ^^ takovej humus v tom se prase vyzná kor když to není potřeba

#18 Atheo
mě se spíš zdá, že sis stále nepřečetl zadání... dobrá vysvětlim to pro tebe ;)

- chce jednoduše to, aby nešla zadat jiná hodnota z konzole, než těch pár čísel, pokud se zadá jiná hodnota, tak se to zeptá znovu na číslo a pokud se zadá správná hodnota, tak se cyklus ukončí a pokracuje dál s číslem barvy

a teď pro tebe..

1) porovnání tam být musí, ať už porovnáváš vstupní barvu s nějakou povolenou (např. v tom while pro každou barvu) nebo jak jsem dělal já pro barvu v poli

2) ve funkci je to lepší? však kde je pak problém? já použil funkci...

3) ty celou dobu meleš něco o barvách pro konzoli, kde jen přes funkci s parametrem barvy vlezen do ní a přes switch zvolíš barvu pro něco, ale zde opět platí, že tam musí být nějaký porovnání a i kdyby ta funkce potom vracela bool, kterej by ukončil cyklus, tak to porovnání tam je... vycházim z toho co si psal a co si poslal za odkazy

takže se vrať na střechy ^^

PS: pokud stále nesouhlasíš s tím co jsem napsal, tak mi sem uvěď kód, jak by jsi to zadání řešil ty a ber v úvahu třeba 20 hodnot barev ;)

#20 ingiraxo
ale však já vím ale kurva co je na tom težkýho ošetřit vstupy bože můj akorát ( v c) 

misto scanf("%d" , &barva); to švihnu do podmínky if(scanf(.. == 1) hotovej zázrak žé? a ten zbytek pěkně do funkce jak sem říkal :P a krásně mi to zas navazuje na sebe O:-)

#21 Atheo
mám dojem, že si nějak nerozumíme :D takto to můžeš dělat pro pár hodnot, ale pokud jich bude třeba 20, tak to už musíš 20x porovnávat (pokud čísla nebudou v postoupnosti)

a tady jsem říkal, že mít v podmínce 20x porovnání není mo hezký, proto jsem to dal do pole a pro porovnání mám funkci

a nějak nechápu co tady není k pochopení nebo co ti vadí na tom :)

#22 ingiraxo
ale to pak není problém ty jen prostě vidíš jedno řešení a to to tvoje... ale ja vidím další a nechce se mi psát celej kód a mejma slovama to prostě nechápeš pokud bych těch vstupu bylo víc tak akorad if(scanf.... == 50000000) pokud by jich bylo 50000000 prostě takhle to jde udělat taky a je to daleko efektivnější využiješ na to jeden řádek a zbytek hodíš do funkce +1 řádek takže ve finále v main.c máš 2 řádky místo cého tvého kódu .. bit je barev 10 nebo 10 milionu

#23 Atheo
mě na tvém kódu nic nevadí :D tuším že jsem psal " ještě bych doplnil jde to i tímto způsobem"....

a ty jsi hned na mě vyjel :D tak snad už si rozumíme 

no protože si napsal tak trochu blbost mimo téma, ale to je jedno, už to nebudu dál řešit ;)

#25 ingiraxo
je pravda ze prvni koment byla kravina protoze jsem si myslel ze chce porovnat cisla = barvy :D a tim to hasne ale myslel jsem to dobre kazdopadne to osetreni cisla je kousek pod tim nu :))

#8 ingiraxo
toto je zle riesenie :) mas tam buffer overflow jak delo sizeof(colors) je vzdy velkost pointra!!! nie velkost pola :)

spravne by to asi malo byt vo vectore aelbo inom zozname a ten prechadzat od zaciatku po koniec ;) to len na okraj :)

#27 nergal
no jo, máš pravdu.. aspoň někdo mě opravil :) hold by se tam přidal další param. pro velikost nebo velikost by byla definice třeba

vektor jsem nechtěl použít, aby to bylo více takový C-like kvůli autorce dotazu

dvoležité je že delicacyy zistil kde má chybu. Toto je ale príklad stvorený na switch ale pchať do toho stringy a funkcie ktoré vyhľadávajú v poly stringov...

Ja by som ten program spravil takto: :)

#include <iostream>
#include <exception>
#include <limits>
using namespace std;

int main(){
	unsigned barva;
	
	cin.exceptions(ios_base::failbit);
	cout << "Zadejte cislo barvy, kterou chcete pouzit a to barvu c. 1, 3, 7, 19 nebo 25" << endl;
	
	while(true){
		cout << ": ";
		try{
			cin >> barva;
		}
		catch(exception&){
			cerr << "Zle zadane cislo!!!" << endl;
			cin.clear();
			cin.ignore(numeric_limits<int>::max(), '\n');
			continue;
		}
		
		switch(barva){
			case 1:
			case 3:
			case 7:
			case 19:
			case 25:
				goto out;	/* 2x break */
		}
	}
	out:	/* goto (2x break) */
	
	cout << "Vybrali jste barvu: " << barva;

	cin.ignore(numeric_limits<int>::max(), '\n');
	cin.get();
	return 0;
}

#30 vitamin
to je celkem brutální řešení si myslim

někde jsem čet, že pokud celý aplikaci použiješ jen jeden try-catch, tak se už celkem zvedají nároky na rychlost app, protože musí kontrolovat hned několik věcí... sice to nebude tak znatelný, ale oproti klasickým pár podmínkám třeba to je o dost

přijde mi mnohem jednodušší udělat vstup na string, pokud barvy jsou čísla, protože pak se nemusim bát chybného vstupu a konverze

ses nechal inspirovat switchem koukam :) tady u pár barev je to celkem jedno, ale kdyby náhodou barev bylo hodně, tak mít switch na 50 řádků.. no nevim O=)

použití goto, si děláš srandu :D je to spíš moje motto, ale pokud někde vidim goto, tak to hned zavání špatnou implementací programu :P

Nemohol som si pomôcť, to goto sa mi tam strašne páči  , viem že by to šlo spraviť napríklad cez jednu bool premennú ktorá by sa testovala v cykle ale to goto je podla mňa prehľadnejšie. 

To o tých výnimkách by ma zaujímalo, kde si to čítal?

Ak tie farby budeš dávať do programu ručne tak ich zadať ako string alebo case N bude rovnako pracné, ale switch bude určite rýchlejší.

nj historický goto, aneb milujeme instrukce jmp :D

ty vyjímky už nevim, je to dlouho, možná tak rok, ale bylo to psaný od nějakýho programátora s několika letou praxí a i logicky bych tomu i věřil, protože přece jen try-catch je pravděpodobně nejnáročnejší blok na nějaký zpracování informací, tudiž bere i větší část výkonu... takže pokud to nejde nějak jinak, tak opravdu try-catch používat v nejkrajnější situaci

ale mělo by to být tak, že pokud je více try-catch bloku v app, tak se výkon nesnižuje už, protože v aplikaci vznikla taková "struktůra" (nemyslim něco jako struct) pro kontrolu dat nebo nevim jak přesně to nazvat, jak říkám, je to dlouho co jsem to čet :)

switch by byl určitě rychlejsí, ale při více/hodně barev bych stejně sáhl po nějakým kontejnéru, je to i takový přirozenejší podle mě a přehlednejší

Tak som si spravil malý testík a ak nenastala žiadna výnimka(prípadne len 1), tak program s výnimkami a program bez výnimiek bol rovnako rýchly. Akonáhle ale nastala výnimka, tak spracovanie výnimky bolo dosť pomalé oproti spracovaniu priamo v kóde. 

#include <cstdio>
#include <iostream>
#include <ctime>
using namespace std;

//******************************************************************************

#define CEIL      200000000
#define RARE      (CEIL - 1)
#define OFTEN     (CEIL - 100000)

#define POUZI_VYNIMKY 


//******************************************************************************

#ifdef POUZI_VYNIMKY
int *rareExceptionTest(int *param) {
	if(*param >= RARE) throw *param;
	return param;
}

//******************************************************************************

int *oftenExceptionTest(int *param) {
	if(*param >= OFTEN) throw *param;
	return param;
}
#endif

//******************************************************************************

int *rareNullTest(int *param) {
	if(*param >= RARE) return NULL;
	return param;
}

//******************************************************************************

int *oftenNullTest(int *param) {
	if(*param >= OFTEN) return NULL;
	return param;
}

//******************************************************************************

void plus_set(int& a, int b){
	a += b;
}
int main(int argc, char *argv[]) {
	long int start;
	int *ret;
	int sum=0;
	
	cout << "stlac ENTER: ";
	cin.get();
	#ifdef POUZI_VYNIMKY
	start = clock();
	for(int i=0; i<CEIL; i++) {
		try {
			ret = rareExceptionTest(&i);
			plus_set(sum, *ret);
		}catch (...) {}
	}
	printf("rare exception:  elapsed %10ld ticks (sum=%d)\n", clock()-start, sum);
	#endif

	
	sum=0;
	start = clock();
	for(int i=0; i<CEIL; i++) {
		ret = rareNullTest(&i);
		if(ret) plus_set(sum, *ret);
	}
	printf("rare null:       elapsed %10ld ticks (sum=%d)\n", clock()-start, sum);
	
	#ifdef POUZI_VYNIMKY
	sum=0;
	start = clock();
	for(int i=0; i<CEIL; i++) {
		try {
			ret = oftenExceptionTest(&i);
			plus_set(sum, *ret);
		}catch (...) {}
	}
	printf("often exception: elapsed %10ld ticks (sum=%d)\n", clock()-start, sum);
	#endif
	
	sum=0;
	start = clock();
	for(int i=0; i<CEIL; i++) {
		ret = oftenNullTest(&i);
		if(ret) plus_set(sum, *ret);
	}
	printf("often null:      elapsed %10ld ticks (sum=%d)\n", clock()-start, sum);
	
	return 0;
}

Program bežal na 64bit linuxe. (gcc 4.7 -O0)

Skús to na win-e, ale pochybujem že v tom bude veľký rozdiel.

Moje výsledky:

//s vvýnimkami:

rare exception:  elapsed    1520000 ticks (sum=-845128447)
rare null:       elapsed    1520000 ticks (sum=-845128447)
often exception: elapsed    1790000 ticks (sum=1722651728)
often null:      elapsed    1530000 ticks (sum=1722651728)

//bez:
rare null:       elapsed    1520000 ticks (sum=-845128447)
often null:      elapsed    1540000 ticks (sum=1722651728)

 Moje (x64 Win7):

// s vyjimkami
rare exception:  elapsed        215 ticks (sum=-845128447)
rare null:       elapsed        168 ticks (sum=-845128447)
often exception: elapsed        839 ticks (sum=1722651728)
often null:      elapsed        169 ticks (sum=1722651728)

// bez
rare null:       elapsed        170 ticks (sum=-845128447)
often null:      elapsed        165 ticks (sum=1722651728)

a teď, když jsem to skompiloval na x64 app:

// s vyjimkami
rare exception:  elapsed        377 ticks (sum=-845128447)
rare null:       elapsed        161 ticks (sum=-845128447)
often exception: elapsed        464 ticks (sum=1722651728)
often null:      elapsed        162 ticks (sum=1722651728)

// bez
rare null:       elapsed        204 ticks (sum=-845128447)
often null:      elapsed        195 ticks (sum=1722651728)

Podľa mňa sú dnes už dobre implementované výnimky a v niektorých prípadoch môžu program aj zrýchliť.

dneska je to už nejspíš jedno.. ono stejně vyjímky nepoužíváš moc často, většinou to jde vyřešit podmínkou a výkon PC je takovej, že nějaký lehký zpomalení (pokud teda opravdu nějaký je) ani nepostřehneš

btw. ty si to testoval na C++11 nebo klasickym ještě?

C++11

Podla mňa ak sa neodhodí výnimka tak môže byť program rýchlejší ako keby sa testovala v if-e a pod. Napríklad: Nech je v programe cyklus ktorí dačo robí. Počas toho ale môžu nastať 4 rôzne málo pravdepodobné udalosti (chyba súboru, nepodarená alokácia, ...). Ak nepoužijeme výnimky, tak v každom prejdení cyklu musíme testovať tieto málo pravdepodobné udalosti. Ak použieme výnimky, tak sa nič netestuje a program ide rýchlejšie. Ak sa odhodí výnimka, tak jej odchytenie je pomalé, ale v konečnom dôsledky je to rýchlejšie ako testovanie výnimočnej udalosti v každom cykle.

edit: 

Tu je zaujímavý článok o výnimkách: http://www.lazarenko.me/c-plus-plus-exception-handling-and-performance/