Составление одного числа из нескольких

int number[] = {1, 8, 9, 7, 9};
int n(0);  //наше число
int j(1);  //множитель
for (int i = 0; i<sizeof number/sizeof (int)-1; i++)
    j*=10;
for (int i = 0; i<sizeof number/sizeof (int); i++, j/=10)
    n += number[i]*j;
cout<<n<<endl;

#include "iostream.h"
 
int main(int argc, char* argv[])
{
    char C[]={'8','2','3','8'};
    int i,r=0,n=sizeof(C);
 
    for (i=0; i<n; i++)
    {
        r=r*10+(C[i]-'0');
    }
 
    cout << r << endl;
 
    return 0;
}

stringstream ss1;
stringstream ss2;
stringstream ss3;
stringstream ss4;
stringstream ss5;
string s1;
string s2;
string s3;
string s4;
string s5;
ss1 << str_ptr[11];
ss1 >> s1;
ss2 << str_ptr[12];
ss2 >> s2;
ss3 << str_ptr[13];
ss3 >> s3;
ss4 << str_ptr[14];
ss4 >> s4;
ss5 << str_ptr[15];
ss5 >> s5;
 
string olelua;
olelua = s1 + s2 + s3 + s4 + s5;
 
int n = atoi(olelua.c_str()); // ÂÎÒ ÎÍÀ ÑÒÐÎÊÀ Ñ ÏÐÅÄÛÄÓÙÈÌ ÏÎÊÀÇÀÍÈÅÌ Ñ×ÅÒ×ÈÊÀ  ÈÍÒÅÅÅÅ
 
cout << n;

char number[] = {7, 8, 9, 7, 9};
int n(0);  //наше число
int j(1);  //множитель
for (int i = 0; i<sizeof number/sizeof (char)-1; i++)
    j*=10;
for (int i = 0; i<sizeof number/sizeof (char); i++, j/=10)
    n += (number[i])*j;  // странно что тут не надо коректно переводить char в int
cout<<n<<endl;

char ch = '0';
int n = ch;
cout<<n<<endl;  // выводит 48, а не 0
int x = ch-48;
cout<<x<<endl;  // нормально

char number[] = {7, 8, 9, 7, 9};

char number[] = {'7', '8', '9', '7', '9'};

char ch = 0;
int n = ch;
cout << n << endl;

#include <iostream>
#include <string>
#include <vector>
#include <stdlib.h>
#include <boost/lexical_cast.hpp>
//---------------------------------------------------------------------------- 
 
//----------------------------------------------------------------------------  
int main()
{
using namespace std;
 
char ch[15]={1};
string str(ch+11,ch+15);
// вариант 1
cout<< atoi( str.c_str() ) <<endl;
// вариант 2 
try
  {
   int i=lexical_cast<int>(string);
   cout<<i<<endl;   
  }
catch(bad_lexical_cast &e)  { cerr<<e.what()<<end;}
 
return 0;
}
//---------------------------------------------------------------------------

#include <iostream>
#include <string>
#include <vector>
#include <stdexcept>
#include <boost/proto/core.hpp>
#include <boost/proto/context.hpp>
 
namespace proto = boost::proto;
using proto::_;
 
template <typename expr>
struct calculator_expression;
 
struct calculator_domain
   : proto::domain <proto::generator <calculator_expression>> { };
 
template <int I> struct placeholder {  };
 
struct calculator_context
   : proto::callable_context <calculator_context const> {
   std::vector <int> v_numbers;
   typedef int result_type;
 
   explicit calculator_context(const std::vector <int> & v_numbers_)
      : v_numbers(v_numbers_) {  }
 
   template <int I>
   int operator ()(proto::tag::terminal, placeholder <I>) const {
      std::string result;
      
      for (auto & val : this->v_numbers) {
         result += std::to_string(val);
      }
    
      return stoi(result);
    }
};
 
template <typename expr>
struct calculator_expression
  : proto::extends <expr, calculator_expression <expr>, calculator_domain>
{
   explicit calculator_expression(expr const & expression = expr())
      : calculator_expression::proto_extends(expression)
   {  }
 
   BOOST_PROTO_EXTENDS_USING_ASSIGN(calculator_expression <expr>)
 
   int operator ()() const {
      calculator_context const ctx;
      return proto::eval(*this, ctx);
   }
 
   int operator ()(const std::vector <int> & v_numbers) const {
      calculator_context const ctx(v_numbers);
      return proto::eval(*this, ctx);
   }
};
 
calculator_expression <proto::terminal <placeholder <1>>::type> const _1;
calculator_expression <proto::terminal <placeholder <2>>::type> const _2;
 
int main() {
   try {
      std::vector <int> v_numbers = { 8, 230, 12, 20, 1 };
      int number = ((_1)(v_numbers));
      std::cout << number << std::endl;
   } catch (const std::out_of_range & exc) {
      std::cerr << exc.what();
   }
   
   return 0;
}