void CMenuLogin::readCommands() { IGUIElement *temp = _gerHud->getFocus(); //_gerHud->setFocus(NULL); if(_gerEventos->isKeyDown(KEY_ESCAPE)) { _nextID = MN_SAIDA; return; } if(_gerEventos->isKeyPressed(KEY_RETURN)) { _gerHud->setFocus(NULL); } if(_gerEventos->isKeyReleased(KEY_RETURN)) { //_nextID = MN_SAIDA; //return; cout << "\nENTER!\n"; } if(_gerEventos->getEventCallerByElement(EGET_BUTTON_CLICKED)) { // Trata os cliques em botões if (_gerEventos->getEventCallerByID() == 101) { // Clicou no botão conectar stringc str1(Login->getText()); strcpy(_login, str1.c_str()); stringc str2(Password->getText()); strcpy(_senha, str2.c_str()); _gameCore->conectar( _login, _senha); // TESTE if(_gameCore->isConnected()) { _nextID = MN_SELECAOPERSONAGEM; return; } } } _gerHud->setFocus(temp); }
int main() { String str1("GeeksQuiz"); String str2 = str1; // CE: deep copies pointer to str1 over to str2 variable using copy constructor defined above str1.print(); // what gets printed? str2.print(); str2.change("GeeksforGeeks"); str1.print(); // what gets printed now? str2.print(); return 0; }
void Movie::Progress::frames_traversed_gdklocked(int n) { frames_done += n; std::ostringstream msg1; msg1 << "0 passes plotted; maxiter = 0; " << npixels << " pixels live"; std::string str1(msg1.str()); std::ostringstream msg2; msg2 << frames_done << "/" << nframes << " frames"; moviebar->set_text(msg2.str()); moviebar->set_fraction((double)frames_done / nframes); pass_complete_gdklocked(str1, 0, 0, npixels, npixels); }
int SHVStringUTF8C::StrCaseCmp(const SHVChar* s1,const SHVChar* s2) { #if defined(__SHIVA_EPOC) SHVStringUTF8 str1(s1); SHVStringUTF8 str2(s2); str1.MakeLower(); str2.MakeLower(); return str1.Compare(str2); #elif defined(__SHIVA_WIN32) return _stricmp(s1,s2); #else return strcasecmp(s1,s2); #endif }
int CTest::test_caseInsensitiveButCasePreserving(int argc, char* argv[]) { AutoPtr<IRawHeaders> h; CRawHeaders::New((IRawHeaders**)&h); String str0("Content-Type"); String str1("text/plain"); h->Add(str0, str1); // Case-insensitive: String strOut; h->Get(str0, &strOut); Boolean flag = strOut.Equals(str1); assert(flag == TRUE); String str2("Content-type"); h->Get(str2, &strOut); flag = strOut.Equals(str1); assert(flag == TRUE); String str3("content-type"); h->Get(str3, &strOut); flag = strOut.Equals(str1); assert(flag == TRUE); String str4("CONTENT-TYPE"); h->Get(str4, &strOut); flag = strOut.Equals(str1); assert(flag == TRUE); // ...but case-preserving: AutoPtr<IMap> innerMap; h->ToMultimap((IMap**)&innerMap); AutoPtr<ISet> keyset; innerMap->KeySet((ISet**)&keyset); AutoPtr<ArrayOf<IInterface*> > array; keyset->ToArray((ArrayOf<IInterface*>**)&array); AutoPtr<ICharSequence> cs = (ICharSequence*)ICharSequence::Probe((*array)[0]); String str5(String("Content-Type")); cs->ToString(&strOut); flag = strOut.Equals(str5); assert(flag == TRUE); // We differ from the RI in that the Map we return is also case-insensitive. // Our behavior seems more consistent. (And code that works on the RI will work on Android.) // AutoPtr<ICharSequence> cs1; // CString::New(String("Content-Type"), (ICharSequence**)&cs1); // AutoPtr<IInterface> value; // innerMap->Get(cs1, (IInterface**)&value); // assertEquals(Arrays.asList("text/plain"), h.toMultimap().get("Content-Type")); // assertEquals(Arrays.asList("text/plain"), h.toMultimap().get("Content-type")); // RI fails this. }
void TestChainElement::TestMoveAndBridge() { ComparisonContext cContext; CRTF_String str1(&cContext, Detached); CRTF_String str2(&cContext, Detached); str1.MoveAndBridge(&str2); assertTest(str1.GetRealBridge()==&str2); assertTest(str2.GetRealBridge()==&str1); assertTest(str1.m_bMove); assertTest(str2.m_bMove); }
//赋值给自己 void Test2(){ printf("Test2 begins:\n"); char* text = "Hello world."; CMyString str1(text); str1 = str1; printf("The expected result is: %s.\n", text); printf("The actual result is: "); str1.Print(); printf(".\n"); }
serverForm::serverForm() { widget.setupUi(this); widget.infoLabel->setText(""); widget.portEdit->setText("17005"); widget.maxAgentEdit->setText("5"); widget.agentCountLabel->setText("0"); widget.idSpusteniaLabel->setText(""); widget.radiusEdit->setText("5000"); widget.radiusEdit->setEnabled(false); widget.startMappingButton->setEnabled(false); widget.stopMappingButton->setEnabled(false); shm_S_GUI = new komunikacia_shm; shm_S_GUI->ukonci_ulohu = 0; shm_S_GUI->mappingNow = 0; shm_S_GUI->widget = &widget; server = new Server(shm_S_GUI); shm_S_GUI->serverForm = (void *) this; struct ifaddrs * ifAddrStruct=NULL; struct ifaddrs * ifa=NULL; void * tmpAddrPtr=NULL; getifaddrs(&ifAddrStruct); std::string str1 ("wlan1"); for (ifa = ifAddrStruct; ifa != NULL; ifa = ifa->ifa_next) { if (!ifa->ifa_addr) { continue; } if (ifa->ifa_addr->sa_family == AF_INET) { // check it is IP4 // is a valid IP4 Address tmpAddrPtr=&((struct sockaddr_in *)ifa->ifa_addr)->sin_addr; char addressBuffer[INET_ADDRSTRLEN]; inet_ntop(AF_INET, tmpAddrPtr, addressBuffer, INET_ADDRSTRLEN); printf("%s IP Address %s\n", ifa->ifa_name, addressBuffer); if (str1.compare(ifa->ifa_name)==0) { widget.ipLabel->setText(addressBuffer); } } else if (ifa->ifa_addr->sa_family == AF_INET6) { // check it is IP6 // is a valid IP6 Address tmpAddrPtr=&((struct sockaddr_in6 *)ifa->ifa_addr)->sin6_addr; char addressBuffer[INET6_ADDRSTRLEN]; inet_ntop(AF_INET6, tmpAddrPtr, addressBuffer, INET6_ADDRSTRLEN); printf("%s IP Address %s\n", ifa->ifa_name, addressBuffer); } } if (ifAddrStruct!=NULL) freeifaddrs(ifAddrStruct); }
void enqueue(queue_t *q, unsigned int val) { std::string str1("enqueue"); //ANNOTATION function_call(str1, INVOCATION, val); //ANNOTATION int success = 0; unsigned int node; pointer tail; pointer next; pointer tmp; node = new_node(); store_32(&q->nodes[node].value, val); tmp = atomic_load_explicit(&q->nodes[node].next, memory_order_seq_cst); set_ptr(&tmp, 0); // NULL atomic_store_explicit(&q->nodes[node].next, tmp, memory_order_seq_cst); while (!success) { tail = atomic_load_explicit(&q->tail, memory_order_seq_cst); next = atomic_load_explicit(&q->nodes[get_ptr(tail)].next, memory_order_seq_cst); if (tail == atomic_load_explicit(&q->tail, memory_order_seq_cst)) { /* Check for uninitialized 'next' */ MODEL_ASSERT(get_ptr(next) != POISON_IDX); if (get_ptr(next) == 0) { // == NULL pointer value = MAKE_POINTER(node, get_count(next) + 1); success = atomic_compare_exchange_strong_explicit(&q->nodes[get_ptr(tail)].next, &next, value, memory_order_seq_cst, memory_order_seq_cst); } if (!success) { unsigned int ptr = get_ptr(atomic_load_explicit(&q->nodes[get_ptr(tail)].next, memory_order_seq_cst)); pointer value = MAKE_POINTER(ptr, get_count(tail) + 1); atomic_compare_exchange_strong_explicit(&q->tail, &tail, value, memory_order_seq_cst, memory_order_seq_cst); thrd_yield(); } } } atomic_compare_exchange_strong_explicit(&q->tail, &tail, MAKE_POINTER(node, get_count(tail) + 1), memory_order_seq_cst, memory_order_seq_cst); function_call(str1, RESPONSE); //ANNOTATION }
int _tmain(int argc, _TCHAR* argv[]) { std::vector<String> vecstr; String str1("tangbin"); String str2("tangbin"); if (str1 == str2) std::cout << "same" << std::endl; vecstr.push_back(str2); vecstr.push_back(str1); String s5 = baz(); // second avoided //vecstr.push_back(str2); //vecstr.push_back(str3); system("pause"); return 0; }
I32 IFXString::CompareNoCase(const IFXCHAR* pSource) const { if(m_Buffer==NULL && pSource==NULL) return 0; else if(m_Buffer==NULL) return -1; else if(pSource==NULL) return 1; IFXString str1(this), str2(pSource); str1.ForceLowercase(); str2.ForceLowercase(); return wcscmp(str1.Raw(), str2.Raw()); }
void push(Deque *q, int x) { std::string str1("push_back"); //ANNOTATION function_call(str1, INVOCATION, (uint64_t) x); //ANNOTATION size_t b = atomic_load_explicit(&q->bottom, memory_order_seq_cst); size_t t = atomic_load_explicit(&q->top, memory_order_seq_cst); Array *a = (Array *) atomic_load_explicit(&q->array, memory_order_seq_cst); if (b - t > atomic_load_explicit(&a->size, memory_order_seq_cst) - 1) /* Full queue. */ { resize(q); //Bug in paper...should have next line... a = (Array *) atomic_load_explicit(&q->array, memory_order_seq_cst); } atomic_store_explicit(&a->buffer[b % atomic_load_explicit(&a->size, memory_order_seq_cst)], x,memory_order_seq_cst); atomic_thread_fence(memory_order_seq_cst); atomic_store_explicit(&q->bottom, b + 1, memory_order_seq_cst); //relaxed function_call(str1, RESPONSE); //ANNOTATION }
bool dequeue(queue_t *q, unsigned int *retVal) { std::string str1("dequeue"); //ANNOTATION function_call(str1, INVOCATION); //ANNOTATION int success = 0; pointer head; pointer tail; pointer next; while (!success) { head = atomic_load_explicit(&q->head, memory_order_seq_cst); tail = atomic_load_explicit(&q->tail, memory_order_seq_cst); next = atomic_load_explicit(&q->nodes[get_ptr(head)].next, memory_order_seq_cst); if (atomic_load_explicit(&q->head, memory_order_seq_cst) == head) { if (get_ptr(head) == get_ptr(tail)) { /* Check for uninitialized 'next' */ MODEL_ASSERT(get_ptr(next) != POISON_IDX); if (get_ptr(next) == 0) { // NULL function_call(str1, RESPONSE); //ANNOTATION return false; // NULL } atomic_compare_exchange_strong_explicit(&q->tail, &tail, MAKE_POINTER(get_ptr(next), get_count(tail) + 1), memory_order_seq_cst, memory_order_seq_cst); thrd_yield(); } else { *retVal = load_32(&q->nodes[get_ptr(next)].value); success = atomic_compare_exchange_strong_explicit(&q->head, &head, MAKE_POINTER(get_ptr(next), get_count(head) + 1), memory_order_seq_cst, memory_order_seq_cst); if (!success) thrd_yield(); } } } reclaim(get_ptr(head)); function_call(str1, RESPONSE, *retVal); //ANNOTATION return true; }
int main(int argc, char **argv) { if (argc != 4) { std::cout << "Usage: " << argv[0] << " <databasefilename> <queryfilename> <tree-type>" << std::endl; return 0; } std::string db_filename(argv[1]); std::string str1(argv[2]); std::string str2(argv[3]); std::cout << "Input file is " << db_filename << " "; std::cout << "String 1 is " << str1 << " and string 2 is " << str2 << std::endl; CheckFile(db_filename); AvlTree<SequenceMap> a_tree; FillTree(db_filename, a_tree); a_tree.print_Between(str1, str2); return 0; }
//(unicode转String) QString Gprs::unicodeTo(QString str) { int temp[400]; QChar qchar[100]; QString strOut; bool ok; int count=str.count(); int len=count/4; for(int i=0;i<count;i+=4) { temp[i]=str.mid(i,4).toInt(&ok,16);//每四位转化为16进制整型 qchar[i/4]=temp[i]; QString str1(qchar, len); strOut=str1; } return strOut; }
int main() { { string str1("AAAA BBBB CCCC EEEE FFFF"); std::vector<string> vec = str1.split(' '); assert(str1=="AAAA BBBB CCCC EEEE FFFF"); assert(vec.size() == 5); assert(vec[0]=="AAAA"); assert(vec[1]=="BBBB"); assert(vec[2]=="CCCC"); assert(vec[3]=="EEEE"); assert(vec[4]=="FFFF"); } }
//连续赋值 void Test3() { cout<<"Test3 begins:"<<endl; const char *text = "hello world"; My_String str1(text); My_String str2,str3; str3 = str2 = str1; cout<<"The experted result is :"<<text<<endl; cout<<"The actual result is :"; str2.Print(); cout<<endl; str3.Print(); cout<<endl; }
// CDialogNew 消息处理程序 void CDialogNew::OnBnClickedOk() { // TODO: 在此添加控件通知处理程序代码 m_EditText.GetWindowTextW(m_Text); if(m_Text == "0" || m_Text == ""|| m_Text.SpanIncluding( _T(".0123456789"))!= m_Text) { CString str1("输入格式不正确,请重新输入!"); CString str2("提示"); MessageBox(str1,str2); m_Text = ""; } else { int nIndex = m_Combobox.GetCurSel(); m_Combobox.GetLBText(nIndex,m_Unit); CDialogEx::OnOK(); } }
void testCountASCIIChars() { vmime::string str1("foo"); VASSERT_EQ("1", static_cast <vmime::string::size_type>(3), stringUtils::countASCIIchars(str1.begin(), str1.end())); vmime::string str2("f=?oo"); VASSERT_EQ("2", static_cast <vmime::string::size_type>(3 + 1), stringUtils::countASCIIchars(str2.begin(), str2.end())); vmime::string str3("foo\x7f"); VASSERT_EQ("3", static_cast <vmime::string::size_type>(4), stringUtils::countASCIIchars(str3.begin(), str3.end())); vmime::string str4("foo\x80"); VASSERT_EQ("4", static_cast <vmime::string::size_type>(3), stringUtils::countASCIIchars(str4.begin(), str4.end())); }
//--------------------------------------------------------------------------------------------------------------------------------------------------- void ProgressBar::DrawProgress() { sprite->Clear(Color::GRAY); sprite->FillRectangle(0, 0, (int)(width * progress), (int)height, Color::BLUE); char buffer[100]; sprintf_s(buffer, 99, "%5.1f%%", progress * 100.0f); textPercents->SetText(String(buffer)); sprintf_s(buffer, 99, "Size: all %5.1fMB, recieved %5.1fMB\n", bytesAll / 1024.0f / 1024.0f, bytesRecieved / 1024.0f / 1024.0f); String str1(buffer); sprintf_s(buffer, 99, "Speed %5.1fkB/s, time: passed %5.1fs, elapsed %5.1fs", speed / 1024.0f, timePassed, timeElapsed); String str2(buffer); text->SetText(currentFile + String("\n") + str1 + str2); }
int main(int argc, char** argv) { value(1); int a = 19; value(std::move(a)); std::string str1("Hello"); std::string str2 = std::move(str1); std::cout << "after move str:" << str1 <<std::endl; // str1 was cleared foo t; t.a = 16; foo s = t; // call copy constructor foo v; v = s; // call operator== return 0; }
void CDialogNew::OnBnClickedOk() { // TODO: 在此添加控件通知处理程序代码 m_EditRow.GetWindowTextW(m_Row); m_EditCol.GetWindowTextW(m_Col); if(m_Row == "" || m_Col == "" || m_Row.SpanIncluding( _T("0123456789"))!= m_Row || m_Col.SpanIncluding( _T("0123456789"))!= m_Col) { CString str1("输入格式不正确,请重新输入!"); CString str2("提示"); MessageBox(str1,str2); m_Row = ""; m_Col = ""; } else { CDialogEx::OnOK(); } }
//--------------------------------------------------------- int main(int argc, char* argv[]) { { std::string str("abc 123 abc 123"); boost::replace_all(str, "123", "abc"); assert(str=="abc abc abc abc"); } { std::string str1, str2; std::vector<std::string> token; str1="one.two"; boost::split(token, str1, boost::is_any_of(".")); str2=boost::algorithm::join(token, "_"); boost::algorithm::replace_all(str2, "_", "."); assert(str1==str2); token.erase(token.begin()); assert(boost::algorithm::join(token, ".")=="two"); } //trim { std::string str1(" 1x x x x1 "); std::string str2("<>trim<>"); std::string str3("123abs343"); assert(boost::trim_left_copy(str1)=="1x x x x1 "); boost::trim_right(str1); assert(boost::trim_left_copy(str1)=="1x x x x1"); assert(boost::trim_copy_if(str2, boost::is_any_of("<>"))=="trim"); assert(boost::trim_copy_if(str3, boost::is_digit())=="abs"); boost::trim_if(str2, boost::is_any_of("<>")); assert(str2=="trim"); } { std::string str("aBc"); boost::to_upper(str); assert(str=="ABC"); boost::to_lower(str); assert(str=="abc"); } return 0; }
//连续赋值 void Test3(){ printf("Test3 begins:\n"); char* text = "Hello world."; CMyString str1(text); CMyString str2, str3; str3 = str2 = str1; printf("The expected result is:%s.\n", text); printf("The actual result is: "); str2.Print(); printf("\n"); str3.Print(); printf("\n"); }
static void test_static_string_equal() { my_static_string_t str0("hello"); my_static_string_t str0b("hello"); my_static_string_t str1("hello!"); my_static_string_t str2("hell"); my_static_string_t a("a"); my_static_string_t b("b"); UF_TEST(str0 == str0b); UF_TEST(!(str0 == str1)); UF_TEST(str0 != str1); UF_TEST(str0 != str2); UF_TEST( a < b); UF_TEST(!(a < a)); UF_TEST(!(b < a)); }
int main(int argc, char** argv) { std::string str1("good thing"); const char* str2("bad thing"); utils::piece pie1(str1); utils::piece pie2(str2); std::cout << "piece1: " << pie1 << " base: " << (void*) pie1.c_str() << std::endl << "piece2: " << pie2 << " base: " << (void*) pie2.c_str() << std::endl; std::cout << "piece1 substr: " << pie1.substr(5) << " base: " << (void*) pie1.substr(5).c_str() << std::endl << "piece2 substr: " << pie2.substr(4) << " base: " << (void*) pie2.substr(4).c_str() << std::endl << "equal? " << (pie1.substr(5) == pie2.substr(4)) << std::endl; typedef boost::tokenizer<utils::space_separator, utils::piece::const_iterator, utils::piece> tokenizer_type; tokenizer_type tokens1(pie1); tokenizer_type tokens2(pie2); for (tokenizer_type::iterator iter = tokens1.begin(); iter != tokens1.end(); ++ iter) std::cout << "token1: " << *iter << " base: " << (void*) (*iter).c_str() << " cast: " << static_cast<std::string>(*iter) << std::endl; for (tokenizer_type::iterator iter = tokens2.begin(); iter != tokens2.end(); ++ iter) std::cout << "token2: " << *iter << " base: " << (void*) (*iter).c_str() << " cast: " << static_cast<std::string>(*iter) << std::endl; const char* str3 = "Good"; const char* str4 = "GOOD"; const char* str5 = "Good-bye"; std::cout << "less: " << (utils::piece(str3) < str4) << std::endl << "greater: " << (utils::piece(str3) > str4) << std::endl << "equal: " << (utils::piece(str3) == str4) << std::endl; std::cout << "less: " << (utils::ipiece(str3) < str4) << std::endl << "greater: " << (utils::ipiece(str3) > str4) << std::endl << "equal: " << (utils::ipiece(str3) == str4) << std::endl; std::cout << "less: " << (utils::ipiece(str3) < str5) << std::endl << "greater: " << (utils::ipiece(str3) > str5) << std::endl << "equal: " << (utils::ipiece(str3) == str5) << std::endl; std::cout << "cast: " << boost::lexical_cast<int>(utils::ipiece("500")) << std::endl; }
TEST(String, Compare) { EXPECT_TRUE(String("abc").compare("abc") == 0); EXPECT_TRUE(String("abc").compare("bbc") < 0); EXPECT_TRUE(String("bbc").compare("abc") > 0); EXPECT_TRUE(String("abc").compare(String("abc")) == 0); EXPECT_TRUE(String("abc").compare(String("bbc")) < 0); EXPECT_TRUE(String("bbc").compare(String("abc")) > 0); EXPECT_TRUE(String("abc").compare("abcd") < 0); EXPECT_TRUE(String("abcd").compare("abc") > 0); EXPECT_TRUE(String("abc").compare(String("abcd")) < 0); EXPECT_TRUE(String("abcd").compare(String("abc")) > 0); // check Strings with embedded nulls std::string str1("a\0bc", 4); std::string str2("a\0bb", 4); EXPECT_TRUE(String(str1).compare(String(str1)) == 0); EXPECT_TRUE(String(str1).compare(String(str2)) > 0); EXPECT_TRUE(String(str2).compare(String(str1)) < 0); }
TEST(EditDistanceBitParallelTest, CalculateEditDistance) { typedef edit_distance_bit_parallel::EditDistanceBitParallel<uint8_t, uint64_t> TestEditDistanceBitParallel; TestEditDistanceBitParallel::Char alphabet_size = 4; TestEditDistanceBitParallel::Char str0_values[] = { 0, 1, 2, 3, 0, 1, 2, 3 }; std::vector<TestEditDistanceBitParallel::Char> str0(&str0_values[0], &str0_values[0] + sizeof(str0_values) / sizeof(str0_values[0])); TestEditDistanceBitParallel::Char str1_values[] = { 0, 0, 2, 3, 0, 1, 2, 3 }; std::vector<TestEditDistanceBitParallel::Char> str1(&str1_values[0], &str1_values[0] + sizeof(str1_values) / sizeof(str1_values[0])); std::vector<TestEditDistanceBitParallel::Word> str0_p_eq(alphabet_size, 0); TestEditDistanceBitParallel editdistance_bit_parallel; editdistance_bit_parallel.BuildPeq(&str0[0], str0.size(), &str0_p_eq[0]); TestEditDistanceBitParallel::Distance distance = editdistance_bit_parallel.CalculateEditDistance( &str0_p_eq[0], &str1[0], str1.size()); EXPECT_EQ(1, distance); }
MathCell* MathParser::ParseCharCode(wxXmlNode* node, int style) { TextCell* cell = new TextCell; wxString str; if (node != NULL && (str = node->GetContent()) != wxEmptyString) { long code; if (str.ToLong(&code)) str = wxString::Format(wxT("%c"), code); #if !wxUSE_UNICODE wxString str1(str.wc_str(wxConvUTF8), *wxConvCurrent); str = str1; #endif cell->SetValue(str); cell->SetType(m_ParserStyle); cell->SetStyle(style); cell->SetHighlight(m_highlight); } return cell; }
int main(int argc, char *argv[]) { // BinaryCode *bc = new BinaryCode(); auto_ptr<BinaryCode> bc (new BinaryCode()); string str1 ("123210122"); vector<string> str1Response = bc->decode(str1); cout << "Dla stringa: " << str1 << endl; cout << "Pierwsza wartość: " << str1Response[0] << endl; cout << "Druga wartość: " << str1Response[1] << endl << endl; string str2 ("11"); vector<string> str2Response = bc->decode(str2); cout << "Dla stringa: " << str2 << endl; cout << "Pierwsza wartość: " << str2Response[0] << endl; cout << "Druga wartość: " << str2Response[1] << endl << endl;; string str3 ("22111"); vector<string> str3Response = bc->decode(str3); cout << "Dla stringa: " << str3 << endl; cout << "Pierwsza wartość: " << str3Response[0] << endl; cout << "Druga wartość: " << str3Response[1] << endl << endl;; string str4 ("123210120"); vector<string> str4Response = bc->decode(str4); cout << "Dla stringa: " << str4 << endl; cout << "Pierwsza wartość: " << str4Response[0] << endl; cout << "Druga wartość: " << str4Response[1] << endl << endl;; string str5 ("3"); vector<string> str5Response = bc->decode(str5); cout << "Dla stringa: " << str5 << endl; cout << "Pierwsza wartość: " << str5Response[0] << endl; cout << "Druga wartość: " << str5Response[1] << endl << endl;; string str6 ("12221112222221112221111111112221111"); vector<string> str6Response = bc->decode(str6); cout << "Dla stringa: " << str6 << endl; cout << "Pierwsza wartość: " << str6Response[0] << endl; cout << "Druga wartość: " << str6Response[1] << endl << endl;; return 0; }