Форум программистов, компьютерный форум, киберфорум
Наши страницы

C++

Войти
Регистрация
Восстановить пароль
 
-=ЮрА=-
Заблокирован
Автор FAQ
#1

Кодировка 8BITMIME - C++

23.09.2011, 11:53. Просмотров 841. Ответов 1
Метки нет (Все метки)

Может у кого есть готовые алгоритмы шифровки base64, можно пример?
0
Надоела реклама? Зарегистрируйтесь и она исчезнет полностью.
Similar
Эксперт
41792 / 34177 / 6122
Регистрация: 12.04.2006
Сообщений: 57,940
23.09.2011, 11:53
Здравствуйте! Я подобрал для вас темы с ответами на вопрос Кодировка 8BITMIME (C++):

Кодировка IP адреса - C++
Помогите пожалуйста закодировать IP адрес в с++:help:

Кодировка - C++ Builder
В общем пишу бот- переводчик через гугл. столкнулся с даной проблемой: дапустим выполняем запрос:...

Кодировка - C++ Builder
пишу самый простой код но русские не поддерживает как изменить кодировку не помню(( #include <stdio.h> #include <conio.h> main ()...

Кодировка проекта - C++ Builder
Можно ли как-то в RAD Studio XE выставить кодировку проекта ? Всем файлам .cpp я выставил кодировку (через Notepad++) UTF-8 без BOOM, а как...

Неправильная кодировка - C++ Builder
Приложение, использующее TServerSocket TClientSocket при передачи сообщений использует непонятную кодировку (китайские символы). Каким...

RichEdit и кодировка - C++ Builder
Здравствуйте! Задача такая: Читаю код страницы в интернете, парсю его и вывожу в richedit: String htmltext =...

1
ForEveR
В астрале
Эксперт С++
7986 / 4745 / 321
Регистрация: 24.06.2010
Сообщений: 10,547
Завершенные тесты: 3
23.09.2011, 13:08 #2
Фасетик из арабики
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
#ifndef ARABICA_BASE64_CODECVT_H
#define ARABICA_BASE64_CODECVT_H
///////////////////////////////////////////
//
// $Id: base64codecvt.hpp 1277 2008-08-06 22:12:05Z jez $
//
///////////////////////////////////////////
 
#include <locale>
#include <SAX/ArabicaConfig.hpp>
#include <Arabica/mbstate.hpp>
 
namespace Arabica
{
namespace convert
{
 
class base64codecvt : public std::codecvt<char, char, std::mbstate_t>
{
public:
  virtual ~base64codecvt() { }
 
protected:
  virtual result do_out(std::mbstate_t& state,
                        const char* from,
                        const char* from_end,
                        const char*& from_next,
                        char* to,
                        char* to_limit,
                        char*& to_next) const;
 
  virtual result do_in(std::mbstate_t& state,
                       const char* from,
                       const char* from_end,
                       const char*& from_next,
                       char* to,
                       char* to_limit,
                       char*& to_next) const;
 
  virtual result do_unshift(std::mbstate_t&  state,
                       char* to,
                       char* to_limit,
                       char*& to_next) const;
 
  virtual int do_encoding() const throw() { return -1; } 
 
  virtual bool do_always_noconv() const throw() { return false; }
 
  virtual int do_length(const std::mbstate_t&,
                        const char* from,
                        const char* end,
                        size_t max) const;
 
  virtual int do_max_length() const throw();
 
private:
  // state here is a little tricky - we need the previous char and
  // the state counter, and in some case we need to "pad" the input
  // strings.  I use these helper functions to mungle them
  // together and keep the details neater (or try to anyway)
  mutable int* state_;
  mutable const char** from_next_;
  mutable const char** from_end_;
  void grabState(std::mbstate_t& state) const;
  void grabFromNext(const char*& from_next) const { from_next_ = &from_next; }
  void grabFromEnd(const char*& from_end) const { from_end_ = &from_end; }
 
  int getState() const;
  void nextState() const;
  int getCurrentOutChar() const;
  void consumeOutChar() const;
  char getPreviousChar() const;
  void setPreviousChar(char c) const;
}; // class base64codecvt
 
} // namespace convert
} // namespace Arabica
 
#endif
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
///////////////////////////////////////////
//
// $Id: base64codecvt.cpp 1036 2007-09-10 16:21:31Z jez $
//
///////////////////////////////////////////
 
#include <convert/base64codecvt.hpp>
 
static const std::string base64_charset("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/");
static const int NO_MORE = 256;
 
using namespace Arabica::convert;
 
std::codecvt_base::result base64codecvt::do_out(std::mbstate_t& state,
                        const char* from,
                        const char* from_end,
                        const char*& from_next,
                        char* to,
                        char* to_limit,
                        char*& to_next) const
{
  // convert to Base64
  grabState(state);
  grabFromNext(from_next);
  grabFromEnd(from_end);
 
  // base64 encode
  from_next = from;
  to_next = to;
 
  // generate the quad
  while((to_next != to_limit) && !((getCurrentOutChar() == NO_MORE) && (getPreviousChar() == 0))) 
  {
    char c = getCurrentOutChar();
    switch(getState())
    {
      case 0:
        *to_next++ = base64_charset[(c>>2) & 63];
        consumeOutChar();
        break;
      case 1:
        *to_next++ = base64_charset[((getPreviousChar() & 3) << 4) + ((c >> 4) & 15)];
        consumeOutChar();
        break;
      case 2:
        *to_next++ = base64_charset[((getPreviousChar() & 15) << 2) + ((c >> 6) & 3)];
        setPreviousChar(0);
        break;
      case 3:
        *to_next++ = base64_charset[(c & 63)];
        consumeOutChar();
        setPreviousChar(0);
        break;
    } // switch(s) 
 
    nextState();
 
    if((getState() == 0) && (getCurrentOutChar() == NO_MORE) && (getPreviousChar() == 0))
      break;
  } // while((from_next < from_end) && (to_next != to_end))
 
  // add padding if needed
  while((getState() != 0) && (to_next != to_limit))
  {
    *to_next++ = '=';
    nextState();
  } // while((state != 4) && (to_next != to_limit))
 
  return ((getState() == 0) && (getCurrentOutChar() == NO_MORE) && (getPreviousChar() == 0)) ? std::codecvt_base::ok : std::codecvt_base::partial;
} // do_out
 
std::codecvt_base::result base64codecvt::do_in(std::mbstate_t& state,
                       const char* from,
                       const char* from_end,
                       const char*& from_next,
                       char* to,
                       char* to_limit,
                       char*& to_next) const
{
  // decode Base64
  grabState(state);
  from_next = from;
  to_next = to;
 
  while((from_next != from_end) && (to_next != to_limit))
  {
    char b = *from_next++;
    size_t i = base64_charset.find(b);
    if(i == std::string::npos)
    {
      if(b == '=')
        nextState();
      continue;
    }
    char c = static_cast<char>(i);
 
    char p = getPreviousChar();
    switch(getState())
    {
      case 0:
        break;
      case 1:
        *to_next++ = (p << 2) | (c >> 4);
        break;
      case 2:
        *to_next++ = (p << 4) | (c >> 2);
        break;
      case 3:
        *to_next++ = (p << 6) | c;
        break;
    } // switch(getState())
    setPreviousChar(c);
    nextState();
  } // while(to != to_limit)
 
  return (from_next == from_end) ? std::codecvt_base::ok : std::codecvt_base::partial; 
} // do_in
 
std::codecvt_base::result base64codecvt::do_unshift(std::mbstate_t& state,
                            char* to,
                            char* to_limit,
                            char*& to_next) const
{
  to_next = to;
 
  // add padding if needed
  while((getState() != 0) && (to_next != to_limit))
  {
    *to_next++ = '=';
    nextState();
  } // while((state != 4) && (to_next != to_limit))
 
  return (to_next == to_limit) ? std::codecvt_base::ok : std::codecvt_base::partial;
} // do_unshift
 
int base64codecvt::do_length(const std::mbstate_t&,
                        const char* from,
                        const char* end,
                        size_t max) const
{
  // 4 base64 chars = 3 chars
  size_t length(end - from);
  size_t quads(((length-1) / 4) + 1);
  size_t chars(quads*3);
 
  // htis next bit isn't exactly right, but it's close enough
  while(chars > max)
  {
    length -= 4;
    chars -= 3;
  } // while(chars > max)
 
  return length;
} // do_length
 
int base64codecvt::do_max_length() const throw()
{
  return 2;
} // do_max_length
 
void base64codecvt::grabState(std::mbstate_t& state) const
{ 
  state_ = reinterpret_cast<int*>(&state); 
  int s = getState();
  if((s < 0) || (s > 4))
    *state_ = 0;
} // grabState
 
int base64codecvt::getState() const
{
  return (*state_) & 0xff;
} // getState
 
void base64codecvt::nextState() const
{
  int s = getState();
  s = s + 1;
  if(s == 4)
    s = 0;
 
  *state_ &= 0xffffff00;
  *state_ |= s;
} // nextOutState
 
int base64codecvt::getCurrentOutChar() const
{
  if(*from_next_ != *from_end_)
    return **from_next_;
 
  return NO_MORE;
} // getCurrentOutChar
 
char base64codecvt::getPreviousChar() const
{
  return static_cast<char>((*state_ &0xff00) >> 8);
} // getCurrentOutChar
 
void base64codecvt::setPreviousChar(char c) const
{
  int bc(c);
  bc <<= 8;
  bc &= 0xff00;
 
  *state_ &= 0xffff00ff;
  *state_ |= bc;
} // setPreviousOutChar
 
void base64codecvt::consumeOutChar() const
{
  if(*from_next_ != *from_end_)
  {
    setPreviousChar(**from_next_);
    *from_next_ = *from_next_ + 1;
  } 
  else
    setPreviousChar(0);
}  // consumeOutChar
 
// end of file
2
MoreAnswers
Эксперт
37091 / 29110 / 5898
Регистрация: 17.06.2006
Сообщений: 43,301
23.09.2011, 13:08
Привет! Вот еще темы с ответами:

Кодировка UTF8 - C++ Builder
Пишу программу текстового конвертера в с++ builder и в результате возникла ошибка. Как конвертировать utf 8 в windows 1251 или в другую...

RichEdit и кодировка - C++ Builder
В общем проблема - когда загружаю в искомый РичЕдит текстовые файлики (LoadFromFile) то если кодировка АНСИ то все прекрасно, а если УТФ-8...

Кодировка текста - C++ Builder
Доброго времени суток, ребята подскажите - мне нужно написать ПО с помощью которого можно будет конвертировать текстовые файлы с любой...

Кодировка в StringGrid - C++ Builder
Привет, форумчане. Столкнулся с такой проблемой: при выводе данных из txt-файла в StringGrid выводятся иероглифы, а с Memo нормально...


Искать еще темы с ответами

Или воспользуйтесь поиском по форуму:
2
Ответ Создать тему
Опции темы

КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2018, vBulletin Solutions, Inc.