Zahl eingeben und diese in einzelne Ziffern zerlegen

NexXxuS

Hallo an alle die mir helfen könnten.

Ich habe gerade ein kleines Problemchen, undzwar: Ich möchte in meinem Programm das so machen dass mich dieses nach einer Zahl frägt und ich diese eingeben und das Programm mir diese Zahl in einzelne Ziffern zerlegt und abspeichert.

Bisher war mein Ansatz so:

int zahl;
	int feld[5];

	cin>>zahl;
	int i=0;
	while(zahl){
	//for(int i=0; i<=5; i++){

		feld[i]=zahl%10;

		zahl/=10;
		//cout<<feld[i] <<endl;
		i++;}

	//Ausgabe der umgekehrten Zahlen
	cout<<feld[4] <<endl;
	cout<<feld[3] <<endl;
	cout<<feld[2] <<endl;
	cout<<feld[1] <<endl;
	cout<<feld[0] <<endl;

Das funktioniert zwar, aber nur wenn diese Zahlen nicht mit einer "0" beginnen, ich brauche das aber so dass es auf jeden Fall 5 stellen sind, deswegen auch ein Feld der Länge 5...

oder diese Lösung, aber hier ist das Problem dass die Werte in einem char abgespeichert werden, und ich nicht mit denen weiterrechnen kann:

int main()
{
	string str;
	cin>>str;
//string str = "hello world";
for( int i = 0; i < str.size(); i++ ){
char c = str[i];
cout<<str[i]<<endl;
}

Gibt es vielleicht eine Lösung die funktioniert wenn auch nuller am anfang stehen?

Vielen Dank im Voraus.

NexXxuS

Vicious Falcon

Nach der Deklaration von feld:

memset(feld,0,sizeof(feld));

Durch das cin>>zahl; werden ja schon führende Nullen "gestrichen".
Oder einfach

int feld[5] = {0};

bestimmt nicht gut aber es tut das, das du willst.

#include <iostream>
using namespace std;

int main ()
{
    int feld[5] = {};

    int zahl;
    cin >> zahl;

    if(zahl > 99999)
    {
        //misst
    }

    int plus = 0;
    if(zahl <= 9999)
    {
        ++plus;
    }

    int i = 0 + plus;
    while(zahl)
    {
        feld[i]=zahl%10;
        zahl/=10;
        i++;
    }
    cout<<feld[4] <<endl;
    cout<<feld[3] <<endl;
    cout<<feld[2] <<endl;
    cout<<feld[1] <<endl;
    cout<<feld[0] <<endl;

    return 0;
}

NexXxuS

@ Dweb

danke für deine Antwort, genau das was ich gesucht habe, nur verstehe ich nicht ganz wieso wenn ich eine führende 0 habe diese dann am Ende ausgegeben wird, habe ich aber 00 am anfang wird eine oben und die andere am ende ausgegeben also feld[4] und feld[0]...

also erstmal das hier:

/*
        Wenn du in {} zu wenige Elemente angibst, werden die restlichen auto.
        mit 0 initialisiert, d.h.:
        {0} und {0,0} und {} etc. --> alles das Selbe.
    */
    int feld[5] = {}; // alle Elemente sind also nun 0.

    int zahl;
    cin >> zahl; // wenn du 00000123 eingbist, werden alle führenden 0 nicht beachtet.
    cout << zahl; // 123

wolltest du genau das hier erreichen ?

#include <iostream>
using namespace std;

int main()
{
    //========================
    int feld[5] = {};
    int i = 0;
    int zahl = 0;
    cin >> zahl;
    //========================

    int laenge = 0;
    int zahl_save = zahl;
    do
    {
        ++laenge;
    }
    while(zahl_save /= 10);	
    //========================

    if(zahl > 99999)
    {
        // misst
    }
    else
    {
        i = 5-laenge;
    }
    //========================

    while(zahl)
    {
        feld[i]=zahl%10;
        zahl/=10;
        i++;
    }
    //========================

    cout<<feld[4] <<endl;
    cout<<feld[3] <<endl;
    cout<<feld[2] <<endl;
    cout<<feld[1] <<endl;
    cout<<feld[0] <<endl;
    //========================

    return 0;
}

NexXxuS

Vielen Dank jetzt funktioniert es... Die Funktion mit ++plus war irgenwie überflüssig.

pumuckl

Wie wärs damit:

bool testeObZahl(std::string vielleichtZahl)
{
  //testen obs ne Zahl ist
  std::stringstream sstr(vielleichtZahl);
  int testZahl;
  sstr >> testZahl;
  return sstr;
}

void zerlegeRueckwaerts(std::string str)
{
  for (std::string::reverse_iterator it = str.rbegin(); it != str.rend(); ++it)
  {
    std::cout << *it << std::endl;
  }
}

void zerlegeZahl()
{  
  std::string vielleichtNeZahl;
  do
  {
    std::cin >> vielleichtNeZahl;
  } while (!testeObZahl(vielleichtNeZahl));

  zerlegeRueckwaerts(vielleichtNeZahl);
}

Wenn was zeichenweise zerlegt werden soll, sollte man es auch zeichenweise bearbeiten - als String nämlich.

HighLigerBiMBam

Man kann es mit deinem zweiten Ansatz machen. Nur finde ich es mit static_cast und new/del fraglich. Sicher kann man mit dem Int-Array nun auch rechnen. Die Benutzereingabe solltest du aber vorher streng kontrollieren.

#include <iostream>
#include <string>

using namespace std;

int main()
{
    string str; 
    cin >> str; 

	int *zahlen = new int [str.size()];

	for( int i = 0; i < str.size(); i++ ){ 
		char c = str[i];
		zahlen[i] = static_cast<int> (c) - 48;
		cout << zahlen[i] << endl;
		}

	delete[] zahlen;
	cin.get();
	cin.get();

	return 0;
}

HighLigerBiMBam schrieb:

char c = str[i];
zahlen[i] = static_cast<int> (c) - 48;

Überlaufen kann das nicht (Grund für int-cast) und was 48 bedeutet weiss nicht jeder (ist auch nicht immer gleich). Deshalb gleich:

zahlen[i] = str[i] - '0';

Klarer und kürzer.

warum nicht so?

int char_to_int(char c) { return c - '0'; }
std::vector<int> zerlege_rueckwaerts(int i)
{
  std::stringstream s;
  s << i;
  std::string str;
  s >> str;
  std::vector<int> vec(str.size());
  std::transform(str.begin()+str.find_first_not_of('0'), str.end(), vec.begin(), char_to_int);
  return vec;
}

void zerlege_zahl()
{  
  int ganz_sicher_ne_zahl;
  while (!(std::cin >> ganz_sicher_ne_zahl));
  std::vector<int> feld = zerlege_rueckwaerts(ganz_sicher_ne_zahl);

  std::cout << feld[0] << std::endl  // das
            << feld[1] << std::endl  // ist
            << feld[2] << std::endl  // natürlich
            << feld[3] << std::endl  // vollkommener
            << feld[4] << std::endl; // Unsinn
}

Ups

std::transform(str.begin()+str.find_first_not_of('0'), str.end(), vec.begin(), char_to_int);

Das komische find_first_of_not kann man sich sparen, lieber so:

std::transform(str.begin(), str.end(), vec.begin(), char_to_int);