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

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

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

int feld[5] = {0};

#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;
}

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]...

/*
        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

#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;
}

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.

#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;
}

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
}

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);