#include <iostream>

int main()
{
  int num;
  std::cin >> std::dec >> num;
  std::cout << std::hex << num << std::endl;
  return 0;
}

// для unsigned.

#define DEC_SIZEOF_INT 10
const char hexArr[16] = "0123456789ABCDEF";

char* Dec2Hex(unsigned num)
{
   char* str = (char*) malloc(DEC_SIZEOF_INT);
   int i;
   for (i = DEC_SIZEOF_INT - 1; i <= 0; --i)
   {
      str[i] = hexArr[num & 0xF];
      num >>= 4;
   }
   return str;
}

int main()
{
unsigned num;
scanf("%d",num);
printf(Dec2Hex(num));
return 1;
}

А>      //num >>= 4; 
/*не на 4, а на sizeof(int)*/
num >>= sizeof(int);

String str = IntToHex(num,8);

F>Под С++ Билдером это ну буквально одна строка

F>String str = IntToHex(num,8);
F>

// эти строки - за пределами собственно решения
char strdec[] = "3735928559";
char strhex[11]; // "0xDEADBEEF\0"

// а вот и оно
sprintf(strhex, "0x%08X", atoi(strdec));

LVV>>Я б поставил трояк

S> Только не надо кидать в меня помидорами, я понимаю, что бывает море исключений из этого правила, но задача преподавателя и есть отсеивать эти исключения... вот ...my humble opinion

прежде чем я (речь лично обо мне) знал о том, что это можно сделать средствами stl я перелопатил столько кода, что в состоянии написать это и на чистом с...

#define X ;

и т.д.

void f()
{
  // . . .
}

int main()
{
  f();
}

main()
{
  for(int dummy, n=0; scanf("%i", &dummy)==1 || (printf("totally %d numbers\n", n), false); ++n) {}
}

К>Никто не мешает использовать оператор ,

К>main()
К>{
К>  for(int dummy, n=0; scanf("%i", &dummy)==1 || (printf("totally %d numbers\n", n), false); ++n) {}
К>}
К>

std::cout << std::accumulate(std::istream_iterator<int>(std::ifstream("F:\\Temp\\in.txt")), std::istream_iterator<int>(), 0);

#include <stdlib.h>
#include <iostream>
void main()
{
  int num;
  std::cin >> num;
  char buf[40];
  _itoa_s(num, buf, 40, 16);
  std::cout << std::endl << buf << std::endl;
}

std::string Dec2Hex(int n)
{
    if (!n)
        return "0";

    const char* pszDict = "0123456789ABCDEF";

    std::string strRes;
    for (; n > 0; n >>= 4)
        strRes = pszDict[n & 0xF] + strRes;

    return strRes;
}

А>>//const char hexArr[16] = "0123456789ABCDEF";
V>/*Зачем выполнять копирование? И тем более прописывать размер массива - пусть компилятор работает за нас!*/
V>const char* const = "0123456789ABCDEF";/ccode]


Строка [ccode]
const char hexArr[16] = "0123456789ABCDEF";

const char* const = "0123456789ABCDEF";

А>//const char hexArr[16] = "0123456789ABCDEF";
/*Зачем выполнять копирование? И тем более прописывать размер массива - пусть компилятор работает за нас!*/
const char* const = "0123456789ABCDEF";

const char* hexArr = "0123456789ABCDEF";

const char* const hexArr = "0123456789ABCDEF";

W>std::cout << std::accumulate(std::istream_iterator<int>(std::ifstream("F:\\Temp\\in.txt")), std::istream_iterator<int>(), 0);
W>

template <class T, class charT = char, class traits = char_traits<charT>, class Distance = ptrdiff_t>
class istream_iterator: public iterator<input_iterator_tag, T, Distance, const T*, const T&>
{
public:
    typedef charT char_type;
    typedef traits traits_type;
    typedef basic_istream<charT,traits> istream_type;
    istream_iterator();
    istream_iterator(istream_type& s);
    istream_iterator(const istream_iterator<T,charT,traits,Distance>& x);
    ~istream_iterator();
    . . .
};

std::cout << std::accumulate(std::istream_iterator<int>(std::ifstream("F:/Temp/in.txt").ignore(0)), std::istream_iterator<int>(), 0);

MS>const char hexArr[16] = "0123456789ABCDEF";
MS>

Change: In C++, when initializing an array of character with a string, the number of characters in the string (including the terminating ’\0’) must not exceed the number of elements in the array. In C, an array can be initialized with a string even if the array is not large enough to contain the string terminating ’\0’
Example:

char array[4] = "abcd"; // valid C, invalid C++

Rationale: When these non-terminated arrays are manipulated by standard string routines, there is potential for major catastrophe.
Effect on original feature: Deletion of semantically well-defined feature.
Difficulty of converting: Semantic transformation. The arrays must be declared one element bigger to contain the string terminating ’\0’.
How widely used: Seldom. This style of array initialization is seen as poor coding style.