#include <iostream>
#include <math.h>
#include <conio.h>
using namespace std;

int main(void)
{
int feld[10];
double feld2[10];
int i = 0, n = 0;

do
{
    cout << "Eingabe: ";
    cin >> feld2[i];

    if(feld2[i] != int(feld2[i]))
    {
               cout << "Nicht korrekt. ";    
    }
    else if(feld2[i] < 10)
    {
               cout << "Eingabe zu klein. ";

    }
    else if(feld2[i] > 20)
    {
               cout << "Eingabe zu gross. ";

    }
    feld[i] = int(feld2[i]);
    i = i + 1;
}
while(i < 10);

int histogramm[10] = {0,0,0,0,0,0,0,0,0,0};
int zehn=10,elf=11;

i = 0;

while(i < 10)
{
                 if(feld[i] == zehn)
                 {
                   histogramm[i] = histogramm[i] + 1;
                 }   
                 else if(feld[i] == elf)
                 {
                      histogramm[i+1] = histogramm[i+1] + 1;
                 }
                 i++;

}         
cout << "Die " << zehn << "wurde " << histogramm[0] << " eingegeben.";
cout << "Die " << elf  << "wurde " << histogramm[1] << " eingegeben.";

cout << endl;

system("pause");
}

Im Zweifelsfall bitte auch folgende Hinweise beachten:
C/C++ Forum :: FAQ - Sonstiges :: Wohin mit meiner Frage?

Dieses Posting wurde automatisch erzeugt.

Besser:

while(i < 10)
{
    if(feld[i] == zehn)
    {
        histogramm[0] = histogramm[0] + 1;
    }   
    else if(feld[i] == elf)
    {
        histogramm[1] = histogramm[1] + 1;
    }
    i++;                  
}

(noch kürzer wäre es, wenn du += oder ++ verwendest)

PS: Wozu brauchst du ein Array mit 10 Elementen, wenn du doch nur die ersten beiden verwendest?

#include <iostream> // std::cout, std::cin
#include <iomanip> // std::setw, std::setfill

Source:

const std::size_t data_size(10);

int main(void)
{
	unsigned int arr_data[data_size];
	unsigned int histogram[10] = { 0 };
	for (std::size_t i(0); i < data_size; ++i)
	{
		do {
			std::cout << "Eingabe (" << i + 1 << ". Zahl): ";
			std::cin >> arr_data[i];
		} while ((arr_data[i] < 10 || arr_data[i] > 20) && (std::cout << "Falsche Eingabe"));
		++histogram[i - 10];
	}

	std::cout	<< "____________________\n"
				<< "| Zahl    | Anzahl |\n"
				<< "====================" << std::endl;
	for (unsigned char i(0); i < 10; ++i)
	{
		std::cout	<< "| " << std::setw(2) << std::setfill('0') << i << "      | " << histogram[i] << "     |\n"
					<< "---------------------" << std::endl;
	}    
	std::cout << "====================" << std::endl;

	std::cin.get();
}

wobei ich jetzt mal nicht auf die Eingabe von Buchstaben eingegangen bin usw.

#include <iostream>
#include <limits> // std::numeric_limits

using namespace std;

void wait();

int main()
{
    int feld[10];
    int feld2[10];
    int i = 0;

    do
    {
        cout << "Eingabe: ";
        cin >> feld2[i];

        if(cin.fail()) // Wenn Eingabe = #.# || #,# || Buchstaben
        {
            cin.clear();
            cin.ignore(numeric_limits<streamsize>::max(), '\n');
            cout << "Eingabe nicht korrekt.\nEs werden nur ganze Zahlen zwischen 10 und 20 erwartet.\nBitte neue ";
        }
        else if(feld2[i] != int(feld2[i]))
        {
             cout << "Nicht korrekt.\nBitte neue ";
        }
        else if(feld2[i] < 10)
        {
             cout << "Eingabe zu klein.\nBitte neue ";
        }
        else if(feld2[i] > 20)
        {
             cout << "Eingabe zu gross.\nBitte neue ";
        }
        else // Damit nicht falsche Eingaben gespeichert werden
        {
            feld[i] = int(feld2[i]);
            ++i; // Nur bei korrekter Eingabe i erhoehen
        }
    }while(i < 10);

    int histogramm[11] = {0};
    int werte[11] = {10,11,12,13,14,15,16,17,18,19,20}; // Array der erlaubten Zahlen zum
                                                        // vergleichen und leichterem ausgeben
    i = 0;

    while(i < 10)
    {
         if(feld[i] == werte[0])
         {
              histogramm[0] += 1;
         }
         else if(feld[i] == werte[1])
         {
              histogramm[1] += 1;
         }
         else if(feld[i] == werte[2])
         {
              histogramm[2] += 1;
         }
         else if(feld[i] == werte[3])
         {
              histogramm[3] += 1;
         }
         else if(feld[i] == werte[4])
         {
              histogramm[4] += 1;
         }
         else if(feld[i] == werte[5])
         {
              histogramm[5] += 1;
         }
         else if(feld[i] == werte[6])
         {
              histogramm[6] += 1;
         }
         else if(feld[i] == werte[7])
         {
              histogramm[7] += 1;
         }
         else if(feld[i] == werte[8])
         {
              histogramm[8] += 1;
         }
         else if(feld[i] == werte[9])
         {
              histogramm[9] += 1;
         }
         else if(feld[i] == werte[10])
         {
              histogramm[10] += 1;
         }
         i++;
    }

    for(size_t i(0);i<11;++i)
    {
        cout << "Die " << werte[i] << " wurde " << histogramm[i] << " mal eingegeben." << endl;
    }
    cout << endl;

    wait(); // Damit die Konsole nicht gleich schliesst

    return 0;
}

void wait()
{
    cin.clear();
    cin.ignore(numeric_limits< streamsize >::max(),'\n');
    cin.get();
}

Die Cracks werden möglicherweise was auszusetzen haben, aber er läuft hier fehlerfrei.

else if(feld2[i] != int(feld2[i]))
        {
             cout << "Nicht korrekt.\nBitte neue ";
        }

wofür der Cast? Du nimmst eh nen int-Array

if(feld[i] == werte[0])
         {
              histogramm[0] += 1;
         }
         else if(feld[i] == werte[1])
         {
              histogramm[1] += 1;
         }
         else if(feld[i] == werte[2])
         {
              histogramm[2] += 1;
         }
         else if(feld[i] == werte[3])
         {
              histogramm[3] += 1;
         }
         else if(feld[i] == werte[4])
         {
              histogramm[4] += 1;
         }
         else if(feld[i] == werte[5])
         {
              histogramm[5] += 1;
         }
         else if(feld[i] == werte[6])
         {
              histogramm[6] += 1;
         }
         else if(feld[i] == werte[7])
         {
              histogramm[7] += 1;
         }
         else if(feld[i] == werte[8])
         {
              histogramm[8] += 1;
         }
         else if(feld[i] == werte[9])
         {
              histogramm[9] += 1;
         }
         else if(feld[i] == werte[10])
         {
              histogramm[10] += 1;
         }
         i++;

und

int werte[11] = {10,11,12,13,14,15,16,17,18,19,20};

. Was fällt auf?

++histogramm[feld[i - 10]];

macht das ganze, ohne deinen Array werte und ohne dieses wiederliche else-if-Konstrukt und mit Inkrementieren ...

Ehm ich sehe mich nicht als crack an, aber da gibt es viel auszusetzen

else if(feld2[i] != int(feld2[i]))
        {
             cout << "Nicht korrekt.\nBitte neue ";
        }

wofür der Cast? Du nimmst eh nen int-Array

hab ich übersehen

(D)Evil schrieb:

++histogramm[feld[i - 10]];

macht das ganze, ohne deinen Array werte und ohne dieses wiederliche else-if-Konstrukt und mit Inkrementieren ...

Hast recht, allerdings musste ich

++histogramm[feld[i]-10];

nehmen damit es wieder funktioniert.

boah im nachhinein könnt ich mir in den arsch beißen.. das ich darauf nicht gekommen bin! kapiere das mit dem inkrement und dekrement operator nicht.. warum setzt du

++histogramm[feld[i - 10]];

die ++ vor das histogramm?! das heißt doch das histogramm = 1 + histogramm[feld[i-10]]; .. oder nicht?! oder wie kann ich das intepretieren?!

++(histogramm[feld[i] - 10]);
// bzw.
histogramm[feld[i] - 10] = histogramm[feld[i] - 10] + 1;

d.h. der Inhalt des Arrayelements wird um eins erhöht (so wie es ja sein soll).

an welche stelle muss ich es setzen, bzw. wie funktioniert es???

i = 0;

    while(i < 10)
    {
         if(feld[i] == werte[0])
         {
              histogramm[0] += 1;
         }
         else if(feld[i] == werte[1])
         {
              histogramm[1] += 1;
         }
         else if(feld[i] == werte[2])
         {
              histogramm[2] += 1;
         }
         else if(feld[i] == werte[3])
         {
              histogramm[3] += 1;
         }
         else if(feld[i] == werte[4])
         {
              histogramm[4] += 1;
         }
         else if(feld[i] == werte[5])
         {
              histogramm[5] += 1;
         }
         else if(feld[i] == werte[6])
         {
              histogramm[6] += 1;
         }
         else if(feld[i] == werte[7])
         {
              histogramm[7] += 1;
         }
         else if(feld[i] == werte[8])
         {
              histogramm[8] += 1;
         }
         else if(feld[i] == werte[9])
         {
              histogramm[9] += 1;
         }
         else if(feld[i] == werte[10])
         {
              histogramm[10] += 1;
         }
         i++;
    }

einfach durch:

for (unsigned char x(0); x < 10; ++x)
    ++histogramm[feld[x] - 10]

ersetzen

Also nochmal von vorne Erklärt:

int zehn=10,elf=11;
int zwoelf=12,drei=13,vier=14,fuenf=15,sechs=16,sieben=17,acht=18,neun=19,zwanzig=20;

Das kannst du ja, wie es "michme" gemacht hat durch einen Array ersetzen, ist dann etwas angenehmer zu nutzen:

int werte[10] = {10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20};

dann ist werte[0] == 10, werte[1] == 11 usw. ... das ist ja schonmal nen ganzes Stück übersichtlicher. Jetzt hast du aber da eine einfache Zahlenreihe, die nur um 10 verschoben ist. Wenn du nun wieder 10 abziehst, erhälst du eine Zahlenreihe, die bei 0 anfängt und somit mit unserem Index von histogramm überein stimmt.
Wenn du vorher dann folgendes hattest:

if (feld[i] == zehn) histogramm[0] += 1;

ersetzt du das, wenn du mit einem Array arbeitest durch:

if (feld[i] == werte[0] /* 10 */) histogramm[0] += 1;
else if (feld[i] == werte[1] /* 11 */) histogramm[1] += 1;
else if (feld[i] == werte[2] /* 12 */) histogramm[2] += 1;

Demnach soll histogramm[0] inkrementiert werden(+= 1), wenn feld[i] == 10 ist. Usw. Wenn du nun aber folgendes machst:

feld[i] - 10

, bekommst du ja, wenn feld[i] == 10 ist, 0 raus, bei 11 1 usw. Also genau den Index, den du bei histogramm haben willst!

histogramm[ feld[i] - 10 ] += 1;

+= 1 ersetzt du nun noch durch ++ und da man Preinkrementierung der Postinkrementierung vorzieht:

++histogramm[ feld[i] - 10 ];

... fertig!

hast mir echt geholfen ! so funktioniert das ! Dankeee, seeehr großen dank !!!

kann mir jemand das mit dem inkrementieren einer variable bzw. dekrementieren mal an einem beispiel erläutern? möcht ejetzt keinen extra thread deswegen aufmachen...

Wäre euch sehr dankbar...

ich hab bisher nur eines im Kopf

// Inkrementieren heißt doch

i++;

//äquivalent zu

i = i + 1; // ?? Stimmt das ?? 

// bzw. Dekrementieren

++i;

//äquivalent zu 

i+1 = i // ???

Dankee !

Hmm der Unterschied wird bsw. hier deutlich:

int array[10]();
unsigned char pos(0);

array[pos++] = 1;
array[pos] = 2;
array[++pos] = 3;