c++ - बढ़ावा कर सकते हैं: एल्गोरिथ्म:: शामिल() concat floats के एक कंटेनर?




string boost (2)

मेरे एसटीएल कौशल कमजोर हैं मैं सोच रहा हूं कि संख्याओं के कंटेनर (फ्लोट्स, डबल्स, इनट्स) के लिए वही समारोह का उपयोग करने के लिए वैसे भी क्या है? ऐसा लगता है जैसे किसी एक या दो-लाइनर को अन्य प्रकारों के लिए इसे अनुकूलित करना चाहिए।

std::accumulate किसी भी (इनपुट) इटरेटर रेंज पर एक गुना करने की अनुमति देता है, एक द्विआधारी फ़ंक्शन का उपयोग करके जो "संचयकर्ता" और अगले आइटम के लिए अलग-अलग प्रकार ले सकता है। आपके मामले में: एक समारोह std::string और एक double (या जो भी) std::to_string जो कि दूसरे पैरामीटर पर std::to_string के परिणाम के साथ दिए गए std::string को std::to_string करता है।

template<typename Container>
std::string contents_as_string(Container const & c,
                               std::string const & separator) {
  if (c.size() == 0) return "";
  auto fold_operation = [&separator] (std::string const & accum,
                                      auto const & item) {
    return accum + separator + std::to_string(item);};
  return std::accumulate(std::next(std::begin(c)), std::end(c),
                         std::to_string(*std::begin(c)), fold_operation);
}

जैसा कि आप देख सकते हैं, यह कंटेनर के मूल्य प्रकार से पूरी तरह से स्वतंत्र है। जब तक आप इसे std::to_string को पास कर सकते हैं आप अच्छे हैं दरअसल, ऊपर कोड std::accumulate के लिए प्रस्तुत उदाहरण का थोड़ा भिन्नता है।

उपर्युक्त कार्य का डेमो :

int main() {
  std::vector<double> v(4);
  std::iota(std::begin(v), std::end(v), 0.1);
  std::cout << contents_as_string(v, ", ") << std::endl;

  std::vector<int> w(5);
  std::iota(std::begin(w), std::end(w), 1);
  std::cout << contents_as_string(w, " x ") << " = "
    << std::accumulate(std::begin(w), std::end(w), 1, std::multiplies<int>{})
    << std::endl;
}

0.100000, 1.100000, 2.100000, 3.100000
1 x 2 x 3 x 4 x 5 = 120

बूस्ट जोड़ने का उपयोग वैकल्पिक रूप से एक विभाजक स्ट्रिंग द्वारा विभाजित स्ट्रिंग के एक कंटेनर को जोड़ने के लिए किया जा सकता है जैसा कि इस उदाहरण में दिखाया गया है: बढ़ावा :: अल्गोरिदम :: शामिल होने के लिए एक अच्छा उदाहरण

मेरे एसटीएल कौशल कमजोर हैं मैं सोच रहा हूं कि संख्याओं के कंटेनर (फ़्लोट्स, डबल्स, इनट्स) के लिए समान फ़ंक्शन का उपयोग करने का कोई तरीका क्या है? ऐसा लगता है कि किसी एक या दो-लाइनर को अन्य प्रकारों के लिए इसे अनुकूलित करना चाहिए।

यहां एक उत्कृष्ट उदाहरण के साथ एसटीएल की प्रतिलिपि समारोह भी है: एक सदिश की सामग्री कैसे मुद्रित करें?

लेकिन मुझे यह पसंद नहीं है कि यह हर तत्व के बाद विभाजक स्ट्रिंग कैसे जोड़ता है। मैं बस को बढ़ावा देने का उपयोग करना चाहते हैं


ज़रूर, आप boost::algorithm::join और boost::adaptors::transformed युग्म को तारों में boost::adaptors::transformed लिए बदल सकते हैं और फिर उन्हें एक साथ जोड़ सकते हैं।

#include <iostream>
#include <vector>
#include <string>

#include <boost/algorithm/string/join.hpp>
#include <boost/range/adaptor/transformed.hpp>

int main()
{
    using boost::adaptors::transformed;
    using boost::algorithm::join;

    std::vector<double> v{1.1, 2.2, 3.3, 4.4};

    std::cout 
      << join( v | 
               transformed( static_cast<std::string(*)(double)>(std::to_string) ), 
               ", " );
}

आउटपुट:

1.100000, 2.200000, 3.300000, 4.400000

बदसूरत कलाकारों से बचने के लिए आप लैम्ब्डा का उपयोग भी कर सकते हैं

join(v | transformed([](double d) { return std::to_string(d); }), ", ")






adapter