Zwei Werte als ein Wert speichern

_Till_

Solche "Variablen" gibt es nicht direkt, aber du köntest zum Beispiel eine String-Klasse nehmen und dann in eine Zahl konvertieren, falls du das willst:

std::string zahl_als_string = "";
zahl_als_string += "1"; // im String steht nun "1"!
zahl_als_string += "2"; // im String steht nun "12"
// so kann das dann ewig weitergehen...
int zahl_als_int = atoi(zahl_als_string.c_str()); // nun hast du einen int-Wert

randa

Hier habe ich mal Lösungsvorschläge gemacht.
Edit: also so:

int PutTogetherB (int a, int b) 
   { 
      int Result; 

      if (b<0) return 0; 
      else if (b<10) a*=10; 
      else if (b<100) a*=100; 
      else if (b<1000) a*=1000; 
      else if (b<10000) a*=10000; 
      else if (b<100000) a*=100000; 
      else if (b<1000000) a*=1000000; 
      else if (b<10000000) a*=10000000; 
      else if (b<100000000) a*=100000000; 
      else if (b<1000000000) a*=1000000000; 

      if (a>=0) Result=static_cast<int> (a+b); 
      else Result=static_cast<int> (a-b); 

      return Result; 
   }

int PutTogether (int a, int b) 
  { 
      int Result; 
     if (b<0) return 0; 

     double Exp=log10 (static_cast<double> (b))+1.0; 
     if (a>=0) Result=static_cast<int> (a*pow (10.0, static_cast<int> (Exp))+b); 
     else Result=static_cast<int> (a*pow (10.0, static_cast<int> (Exp))-b); 

     return Result; 
  }

//per Stringstream 
 ss << Eine Zahl << NochEineZahl; 
 ss >> Die ErgebnisZahl;

phlox81

Das kann man doch schön rekursiv lösen, und gleich noch in ein Template packen:

template<class A, class B, class Max= int>
class puttogether
{
	A a;
	B b;
	A erg;
	Max start;
	void Put(Max m)
	{
		if(b <= 0)
			erg = 0;
		else
		{
			if(b < m)
				a *= m;
			else
				Put(m*10);
		}
		if(a >=0)
			erg = static_cast<A>(a+b);
		else
			erg = static_cast<A>(a-b);
	}
public:
	puttogether( A a, B b, Max start = 10):a(a),b(b),erg(0),start(start){Put(start);}
	friend std::ostream& operator<<(puttogether<A,B,Max>& put,std::ostream& o);

	A GetErgebnis()
	{
		return erg;
	}
};
template<class A, class B, class Max= int>
std::ostream& operator<<(std::ostream& o,puttogether<A,B,Max>& put)
	{
		o << put.GetErgebnis();
		return o;
	}

Devil

randa

Warum so kompliziert?
Außerdem ist das wohl etwas langsamer.

Jeder Speicherplatz eines bestimmten Typs kann nur einen (!) Wert speichern! Alles andere ist ein Krampf. Warum nur? Man kriegt sie doch so schwer wieder auseinander. Was solls also?

randa

lilo schrieb:

Jeder Speicherplatz eines bestimmten Typs kann nur einen (!) Wert speichern!

Das war gar nicht wirklich die Problemstellung. Er wollte zwei Zahlen zu einer vereinigen. Das resultiert dann in _einem_ Wert, der in _einer_ Variablen gespeichert ist

Übrigens kann man durchaus zwei separate Werte in einer Variablen speichern, z.b. 1 int = 2 short int, und auf die kann man auch zugreifen.

phlox81

Hab die Lösung jetzt noch iterativ angepasst, ist evtl. bisschen schneller als mit rekursion:

template<class A, class B, class Max= int>
class puttogether
{
	A a;
	B b;
	A erg;
	Max start;
	void Put(Max m)
	{
		if(b <= 0)
			erg = 0;
		else
		{
			while(b => m)
				m *= 10;
			a*=m;
		}
		if(a >=0)
			erg = static_cast<A>(a+b);
		else
			erg = static_cast<A>(a-b);
	}
public:
	puttogether( A a, B b, Max start = 10):a(a),b(b),erg(0),start(start){Put(start);}
	friend std::ostream& operator<<(puttogether<A,B,Max>& put,std::ostream& o);

	A GetErgebnis()
	{
		return erg;
	}
};
template<class A, class B, class Max= int>
std::ostream& operator<<(std::ostream& o,puttogether<A,B,Max>& put)
	{
		o << put.GetErgebnis();
		return o;
	}

Alternativ könnte man es natürlich auch in ne tempatefunktion packen.

Devil

Wie wärs mit der offensichtlichen Alternative - stringstream?

#include <sstream>
#include <string>

using namespace std;

int main() {
  std::stringstream sstr;
  string s;

  sstr << 1 << 2 << "fooba" << 'r' << 3.14159;
  s = sstr.str();

  cout << s << endl;
}

Oh, und wenn du nachher den Wert wieder als Zahl brauchst, halt so:

#include <iostream>
#include <sstream>
#include <string>

int main() {
  std::stringstream sstr;
  int i;

  sstr << 1 << 2;
  sstr >> i;

  std::cout << i * 2 << std::endl; // gibt 24 aus
}

randa

@0xdeadbeef:
Die stringstream-Variante wurde schon mehrfach gepostet.
Sie ist natürlich am offensichtlichsten, aber viel effizienter geht's durch etwas rechnen.