การป้อนองค์ประกอบประเภทที่ไม่รู้จักลงในเวกเตอร์

C++ คือภาษาที่พิมพ์ แบบคงที่ หมายความว่าควรกำหนดทุกประเภทในระหว่างการคอมไพล์: คุณไม่สามารถแนะนำประเภทใหม่เมื่อรันโปรแกรม

• การสร้างเวกเตอร์ประเภทโมฆะ (เห็นได้ชัดว่าไม่ได้รับอนุญาตตอนนี้เมื่อฉันค้นคว้าแล้ว โอ๊ะโอ)

void จริงๆ แล้วเป็นประเภทที่ค่อนข้างแปลก โดยส่วนใหญ่เป็นตัวยึดตำแหน่งสำหรับเวลาที่คุณคาดหวังประเภท (เช่น ประเภทการส่งคืนฟังก์ชัน) และไม่มีข้อมูลให้ void* ใช้เป็นตัวชี้ไปยังประเภทที่ไม่รู้จัก (ส่วนใหญ่เป็นภาษา C) แต่นี่ค่อนข้างเป็นการแฮ็ก เนื่องจากข้อมูลเกี่ยวกับต้นฉบับถูกละทิ้ง (เท่าที่เกี่ยวกับภาษา) ดังนั้นจึงทำให้เกิดปัญหาในการทำสิ่งต่าง ๆ ด้วยค่าจริง ได้รับดังนั้น

• การโอเวอร์โหลดฟังก์ชันที่เรียกว่า insertInVector โดยการส่งองค์ประกอบแรกไปยังฟังก์ชัน และปล่อยให้ฟังก์ชันกำหนดประเภทเวกเตอร์ที่จะสร้างตามประเภทขององค์ประกอบแรก

• #include <typeinfo> ในโปรแกรม ค้นหาประเภทขององค์ประกอบแรก จากนั้นสร้างเวกเตอร์โดยใช้ vector<typeid(firstElement).name()> และจริงๆ แล้วฉันไม่แน่ใจว่าทำไมมันถึงใช้งานไม่ได้ แต่มันก็ไม่ได้ผล

น่าเสียดายที่เป็นไปไม่ได้: เนื่องจากคุณไม่สามารถประกาศตัวแปรโดยไม่มีประเภทได้ firstElement จะขึ้นต้นด้วยประเภทใด

ปัญหาที่คุณกำลังอธิบายโดยทั่วไปนั้นยาก โดยพื้นฐานแล้วหมายความว่าคุณจะต้องยอมรับชุดอักขระ จากนั้นจึงเขียนโค้ดชุดกฎเพื่อกำหนดวิธีตีความอักขระเหล่านั้น ซึ่งทำได้โดยทั่วไปโดยใช้ ไวยากรณ์ เพื่อเข้ารหัสกฎเหล่านั้น แต่ไวยากรณ์อาจจะซับซ้อนสำหรับงานง่ายๆ

ผมขอยกตัวอย่างเล็กๆ น้อยๆ:

class Input {
public:
    enum Type {
        Int,
        Double,
        String
    };

    static Input Parse(std::string const& s);

    Input(): _type(Int), _int(0), _double(0.0) {} // need to define a default...

    Type type() const { return _type; }

    int asInt() const {
        assert(_type == Int && "not an int");
        return _int;
    }

    double asDouble() const {
        assert(_type == Double && "not a double");
        return _double;
    }

    std::string const& asString() const {
        assert(_type == String && "not a string");
        return _string; 
    }

private:
    Type _type;
    int _int;
    double _double;
    std::string _string;
};

แน่นอนว่าความท้าทายที่แท้จริงคือการ Parse อินพุตให้ถูกต้อง

แนวคิดคือการใช้ชุดกฎเกณฑ์ เช่น

• int ประกอบด้วยตัวเลขเท่านั้น หรืออาจขึ้นต้นด้วย - ก็ได้
• a double ประกอบด้วยตัวเลขเท่านั้น โดยมี . มากที่สุดหนึ่งตัว และเติมคำนำหน้าด้วย - หรือไม่ก็ได้
• a string สามารถเป็นอะไรก็ได้ ดังนั้นจึงเป็นสิ่งที่จับได้ทั้งหมดของเรา

จากนั้นเราสามารถเขียนส่วนการจดจำของเมธอด Parse ได้:

static bool isInt(std::string const& s) {
    if (s.empty()) { return false; }
    
    // The first character may be among digits and '-'
    char const first = s.at(0);
    if (not isdigit(first) and first != '-') { return false; }

    // Subsequent characters may only be digits
    for (char c: s.substr(1)) {
        if (not isdigit(c)) { return false; }
    }

    // Looks like it is an int :)
    return true;
} // isInt

// Note: any int could be interpreted as a double too
static bool maybeDouble(std::string const& s) {
    if (s.empty()) { return false; }

    // The first character may be among digits, '.' and '-'
    char const first = s.at(0);
    if (not isdigit(first) and first != '.' and first != '-') { return false; }

    // There may only be one dot
    bool hasSeenDot = s.at(0) == '.';

    // Subsequent characters may only be digits and a dot now
    for (char c: s.substr(1)) {
        if (not isdigit(c) and c != '.') { return false; }

        if (c == '.') {
            if (hasSeenDot) { return false; } // no second dot allowed
            hasSeenDot = true;
        }
    }

    // Looks like it could be a double
    return true;
} // maybeDouble

static Input::Type guessType(std::string const& s) {
    if (isInt(s)) { return Input::Int; }

    // Test double after we ensured it was not an int
    if (maybeDouble(s)) { return Input::Double; }

    return Input::String;
} // guessType

และด้วยตรรกะการเดาร่วมกัน ในที่สุดการแยกวิเคราะห์ก็มาถึง:

Input Input::Parse(std::string const& s) {
    Input result;

    result._type = guessType(s);

    switch(result._type) {
    case Input::Int: {
        std::istringstream stream(s);
        s >> result._int;
        return result;
    }
    case Input::Double: {
        std::istringstream stream(s);
        s >> result._double;
        return result;
    }
    case Input::String:
        result._string = s;
        return result;
    }

    // Unreachable (normally)
    abort();
} // Input::Parse

วุ้ย

ดังนั้น ? เกือบจะมี. ตอนนี้เราจำเป็นต้องกำหนดวิธีเปรียบเทียบสองอินพุต เป็นเรื่องง่ายหากทั้งหมดมีประเภทเดียวกัน ถ้าไม่เช่นนั้น คุณจะต้องกำหนดตรรกะที่กำหนดเอง คุณสามารถแปลงอินพุต Int ในอินพุต Double ได้อย่างง่ายดายเพียงพอ แต่สำหรับสตริงมันจะแปลกกว่าเล็กน้อย

// define < for comparing two instance of "Input",
// assuming they both have the same type
bool operator<(Input const& left, Input const& right) {
    assert(left.type() == right.type() && "Different Types!");

    switch(left.type()) {
    case Input::Int: return left.asInt() < right.asInt();
    case Input::Double: return left.asDouble() < right.asDouble();
    case Input::String: return left.asString() < right.asString();
    }
} // operator<

และสุดท้ายคือโปรแกรม:

int main(int argc, char* argv[]) {
    // parse command line
    std::vector<Input> inputs;

    // by convention argv[0] is the program name, it does not count!
    for (int i = 1; i != argc; ++i) {
        inputs.push_back(Input::Parse(argv[i]));

        // Detect that the type is the same as the first input
        if (inputs.size() >= 2) {
            if (inputs.back().type() != inputs.front().type()) {
                std::cerr << "Please only use one type among Int, Double and String\n";
                return 1; // non-0 is an error
            }
        }
    }

    // sort
    std::sort(inputs.begin(), inputs.end());

    // echo back to the user
    for (Input const& i: inputs) {
        switch(i.type()) {
        case Input::Int: std::cout << i.asInt() << "\n"; break;
        case Input::Double: std::cout << i.asDouble() << "\n"; break;
        case Input::String: std::cout << i.asString() << "\n"; break;
        }
    }

    // End of the program
    return 0;
}

แน่นอนว่าฉันไม่รู้ว่าคุณต้องการจัดการกับประเภทไหน .. ฉันตัดสินใจเลือกชุดที่ต้องการแล้ว ;) อย่างไรก็ตาม สิ่งนี้น่าจะให้โครงกระดูกแก่คุณในการวางรากฐาน

เมื่อดูข้อกำหนดที่แท้จริงของปัญหาตามที่ระบุไว้ในความคิดเห็น ฉันขอแนะนำให้คุณเก็บอินพุตทั้งหมดใน std::vector<std::string> และจัดเรียงเวกเตอร์โดยใช้ std::sort ดังนั้น แทนที่จะกังวลเกี่ยวกับประเภทต่างๆ คุณสามารถระบุตรรกะการเรียงลำดับได้ โดยขึ้นอยู่กับสิ่งที่คุณตีความสตริงในเวกเตอร์ของคุณเพื่อนำเสนอ ดังนั้น

1. ใช้ฟังก์ชันการเรียงลำดับสำหรับสตริงโดยขึ้นอยู่กับว่าสตริงเป็นตัวแทนอะไร (เพิ่มเติมในภายหลัง)
2. เก็บอินพุตเป็นสตริงในเวกเตอร์
3. กำหนดประเภทที่สตริงเป็นตัวแทน
4. เลือกฟังก์ชันการเรียงลำดับตามประเภทนี้
5. จัดเรียงเวกเตอร์โดยใช้ std::sort และฟังก์ชันการเรียงลำดับที่เหมาะสม

เกี่ยวกับฟังก์ชันการเรียงลำดับ std::sort ยอมรับไบนารีฟังก์ชันหรือฟังก์ชันที่ใช้การเปรียบเทียบ "น้อยกว่า" กับสององค์ประกอบ ดังนั้นฟังก์ชันหรือฟังก์ชันของคุณควรมีลักษณะดังนี้

bool foo(const std::string& rhs, const std::string& lhs) {
  // implement the logic
}

แก้ไข: เมื่อดูความคิดเห็นล่าสุด ดูเหมือนว่าจุดประสงค์หลักหากแบบฝึกหัดอาจเป็นการใช้อัลกอริธึมการเรียงลำดับสำหรับประเภทต่างๆ ในกรณีนั้น ฉันขอแนะนำให้ปฏิบัติตามแนวทางที่ไลบรารีมาตรฐาน C++ นำไปใช้ นั่นคือ เพื่อใช้การเรียงลำดับในแง่หรือการเปรียบเทียบ น้อยกว่า ระหว่างสองประเภท ดังนั้นจึงแยกตรรกะการเรียงลำดับออกจากประเภท ที่จะจัดเรียง ดังนั้น คุณจึงต้องการฟังก์ชันการเรียงลำดับเทมเพลต ซึ่งมีเทมเพลตตามประเภทตัววนซ้ำและฟังก์ชัน/ฟังก์ชันการเปรียบเทียบ

หากคุณทราบว่าผู้ใช้สามารถป้อนข้อมูลประเภทใด คุณสามารถใช้เทมเพลตและการสืบทอดได้:

class Generic {
public:
  virtual void process_input() = 0; // Handles the next input from user
  virtual void process_output() = 0; // Processes the data inserted
};

template <typename T>
class HandleInput : public Generic {
private:
    std::vector<T> storage;
public:
    HandleInput(T first)
    {
      storage.push_back(first);
    }

    void process_input()
    {
      // do whatever you want
    }

    void process_output()
    {
      // do whatever you want
    }
};

int main(int argc, char **argv)
{
  // Get first input
  Input i = input();
  Generic *g;

  // Instantiate the "right" generic with a switch
  switch (i.type) {
    case T:
      g = new HandleInput<T>(i.value);
  }

  // Use Generic from here onwards
}

นั่นเป็นเพียงแนวคิด (Input ไม่สามารถนำไปใช้เช่นนั้นได้ คุณต้องเปลี่ยนส่วนนั้นด้วยตรรกะที่ได้รับบางอย่างจากผู้ใช้และกำหนดประเภทของมัน) แต่มันมีประโยชน์ในการมาสก์ประเภทนั้นเป็นคลาสทั่วไป ดังนั้นคุณจึงสามารถ แยกตัวประกอบโค้ดของคุณรอบๆ อินเทอร์เฟซที่จัดทำโดย Generic

แนวคิดอีกอย่างหนึ่ง (ง่ายกว่านั้นน่าจะ) คือการใช้ std::vector<void*> และ enum ที่บอกคุณว่าประเภทของข้อมูลที่จัดเก็บไว้ในเวกเตอร์คืออะไร เมื่อคุณจำเป็นต้องประมวลผลข้อมูลนั้นที่ใดที่หนึ่งในอนาคต คุณสามารถเปิด enum เพื่อแปลงองค์ประกอบเวกเตอร์ให้เป็นประเภทที่ถูกต้องและส่งไปยังโค้ดที่เหมาะสมได้

แก้ไข: อีกแนวคิดหนึ่งคือการกำหนดฟังก์ชันเทมเพลตที่รับอินพุตและเรียงลำดับอาร์เรย์โดยใช้ตัวเปรียบเทียบมาตรฐาน:

#include <iostream>

#include <vector>
#include <algorithm>
#include <boost/lexical_cast.hpp>

template <typename T>
void print_v(std::vector<T> &v)
{
    typename std::vector<T>::iterator it;
    for (it = v.begin(); it != v.end(); it++)
        std::cout << *it << " ";
    std::cout << std::endl;
}

template <typename T>
void sort_and_print(T first, size_t n, bool asc)
{
    std::vector<T> v;
    v.push_back(first);
    for (size_t i = 0; i < n; i++) {
        std::string s;
        std::cin >> s;
        T e = boost::lexical_cast<T>(s);
        v.push_back(e);
    }

    print_v(v);
    if (asc)
        std::sort(v.begin(), v.end(), std::greater<T>());
    else
        std::sort(v.begin(), v.end());
    print_v(v);
}

int main(int argc, char **argv)
{
    std::string s = "test";
    sort_and_print(s, 2, true);
    unsigned int j = 3;
    sort_and_print(j, 2, true);
    return 0;
}

ตรรกะในการกำหนดประเภทของอินพุตแรกนั้นขึ้นอยู่กับคุณ (บางทีคุณสามารถเปิดคำถามอื่นได้) ;)

คำถามนี้มีสองประเด็น: การแยกวิเคราะห์และการเรียงลำดับ

• คุณสามารถใช้ นิพจน์ทั่วไป เพื่อตรวจสอบประเภทข้อมูลที่ผู้ใช้ป้อน
• คุณสามารถใช้ cin เพื่อแยกวิเคราะห์ข้อมูล

ขั้นแรก: ตระหนักว่าคุณไม่สามารถจำเป็นทราบประเภทของการป้อนข้อมูลของผู้ใช้ของคุณจนกว่าคุณจะได้รับทั้งหมด ~เช่น: พิจารณารายชื่อผู้ใช้ ชื่อ :

728278243
390349346
495045594
elizabeth

ดังนั้น ไม่ควรถือว่ารู้ดีที่สุดเกี่ยวกับข้อมูลขาเข้า (อาจนำไปสู่ประสบการณ์ผู้ใช้ที่น่าหงุดหงิด) แต่เลือกที่จะปฏิบัติต่อทุกอย่างเหมือนเป็นสตริงแทน จัดเก็บอินพุตดิบทั้งหมดเป็นสตริง เพื่อให้คุณสามารถเอาต์พุตในรูปแบบเดียวกับอินพุตได้ คุณสามารถใช้ say ซึ่งเป็นประเภทที่แจกแจงเพื่อสลับภายในตัวเปรียบเทียบการเรียงลำดับ หรือ พิจารณาใช้ mutliset/multimap ที่นี่ คุณจะสร้างชุด สั่งซื้อ ดังนั้นจึงไม่จำเป็นต้องเรียงลำดับ หมายเหตุ: ความซับซ้อนในการสร้างชุดลำดับขององค์ประกอบ N หรือ สำหรับการเรียงลำดับเดี่ยวบนองค์ประกอบรายการที่ไม่เรียงลำดับ N นั้นเทียบเท่าโดยประมาณ ~> NlogN

สำหรับงานในมือของคุณ มันแทบจะไม่สำคัญเลย แต่ในความเป็นจริงแล้ว ขึ้นอยู่กับวิธีการใช้รายการ แนวทางใดวิธีหนึ่งจะเหมาะสมกว่าในแง่ของประสิทธิภาพ

หากคุณได้ใช้การถูกใจของ std::vector แล้ว std::multimap ก็ไม่น่าจะน่ากลัวเกินไป โดยทั่วไปแล้ว มันเป็นอาร์เรย์ที่เกี่ยวข้องกันของคู่คีย์-ค่า multi ที่นี่หมายความว่ามันสามารถเก็บหลายองค์ประกอบด้วยคีย์ เดียวกัน (ซึ่งที่นี่คุณต้องการ)

ในตัวอย่างนี้ ฉันกำลังใช้ไลบรารี boost regex เพื่อกำหนดประเภทข้อมูลอินพุต funky บางส่วน
(เช่น: sudo apt-get install libboost-regex1.46-dev)

regex นี้อาจดูเป็นความลับ แต่มีตัวอย่างมากมายบน i/web สำหรับเกือบทุกรูปแบบที่เป็นไปได้ [หมายเหตุ: C++11 regex ค่อนข้างเป็นการแทนที่แบบดรอปอินสำหรับ boost regex เช่น: boost regex ควรเข้ากันได้กับมาตรฐาน C ++ 11 ที่เกิดขึ้นใหม่]

blah.cpp:

#include <iostream>
#include <sstream>
#include <string>
#include <list>
#include <map>
#include <set>
#include <boost/regex.hpp>    
//NB: GNU gcc added *experimental support for regular expressions in TR1 v 4.3.0.
//    compile with:  -std=c++0x

using namespace std;
using namespace boost;

//some example input data-types (perhaps notably missing a date!) 
const regex re_char("[^0-9]", regex_constants::extended); //non numeric chars
const regex re_digit("[[:digit:]]+", regex_constants::extended); //a string of only digits in range [0..9] ~ie: Z+
const regex re_xdigit("0[xX][[:xdigit:]]+", regex_constants::extended); //support hex iff starts with '0x' or '0X'
const regex re_float("[-+]?[0-9]*\\.?[0-9]+([eE][-+]?[0-9]+)?", regex_constants::extended); //all kinds of numbers


int main(int argc, char** argv)
{    
    int i, countc=0;
    double d;
    string str;
    int element_count;    

    do
    {
        cout << "how many elements will there be? "; 
        if (cin >> element_count) break;
        cin.clear();
        cin >> str;
        cout << "\033[A\033[2K" << flush;
    }
    while(13);
    cin.ignore(128,'\n'); 

    multimap<double, string> list_num; 
    multimap<double, string> list_fp; 
    //NB: below, by way of example, construction using the 'greater<int>' comparison class achieves _descending_ order 
    multimap<int, string, greater<int> > list_int; 
    list<string> list_str; 

    for (int next=0; next < element_count; next++)
    {
        cout << "\033[A\033[2K" << flush;
        cout << "enter next element in list ["<< next+1 << "/" << element_count << "] : "; 
        getline (cin,str);

        if (regex_match(str, re_xdigit))
        {
            //see all about manipulators here:
            //http://www.cplusplus.com/reference/iostream/istream/operator%3E%3E/
            stringstream(str) >> hex >> i;            
            list_int.insert(pair<int, string>(i, str)); 
            list_num.insert(pair<double, string>(i, str)); 
        }
        else if (regex_match(str, re_digit))
        {
            stringstream(str) >> i;            
            list_int.insert(pair<int, string>(i, str));            
            list_num.insert(pair<double, string>(i, str)); 
        }
        else if (regex_match(str, re_float))
        {
            stringstream(str) >> d;    
            list_fp.insert(pair<double, string>(d, str));        
            list_num.insert(pair<double, string>(d, str)); 
        } 

        if (regex_match(str, re_char)) countc++;      
        list_str.push_back(str);
    }    

    cout << "\033[A\033[2K" << flush;

    cout << "input: unsorted list:" << endl;
    for (list<string>::iterator it=list_str.begin(); it!=list_str.end(); it++) 
        cout << *it << endl;

    if (list_int.size() == element_count)
    {
        cout << endl << "output: sorted list of Z+ types:" << endl;
        for (multimap<int, string>::iterator it=list_int.begin() ; it != list_int.end(); it++ )
            cout << (*it).second << endl;
    }
    else if (list_fp.size() == element_count)
    {
        cout << endl << "output: sorted list of fp types:" << endl;
        for (multimap<double, string>::iterator it=list_fp.begin() ; it != list_fp.end(); it++ )
            cout << (*it).second << endl;
    }
    else if (list_num.size() == element_count)
    {
        cout << endl << "output: sorted list of numeric types:" << endl;
        for (multimap<double, string>::iterator it=list_num.begin() ; it != list_num.end(); it++ )
            cout << (*it).second << endl;
    }
    else //output as sorted strings ~but in _descending_ order, using reverse iterator, by way of example
    {
        list_str.sort(); //but best to use list_str.sort(greater<string>()); with forward iterators
        cout << endl << "output: sorted list of " <<  (countc == element_count ? "non numeric char" : "string") << " types:" << endl;
        for (list<string>::reverse_iterator it=list_str.rbegin(); it!=list_str.rend(); ++it) 
            cout << *it << endl;        
    }   

    return 0;
}

ตัวอย่างถูกรวบรวมและรันบน Ubuntu สิ่งบรรทัดคำสั่ง:

$
$ lsb_release -d
Description:    Ubuntu 11.10

$ g++ --version
g++ (Ubuntu/Linaro 4.6.1-9ubuntu3) 4.6.1 

$ g++ --pedantic -oblah blah.cpp -lboost_regex
$ ./blah
input: unsorted list:
4.77
2.0e+2
-.3
11
0x10

output: sorted list of numeric types:
-.3
4.77
11
0x10
2.0e+2
$

หมายเหตุ: นี่คือโค้ดตัวอย่าง:

• มีการเพิ่มประสิทธิภาพมากมายที่สามารถทำได้ที่นี่ เห็นได้ชัดว่าคุณไม่จำเป็นต้องต้องการคอนเทนเนอร์ stl มากเท่าที่ฉันใช้อยู่
• ฉันไม่ได้จัดการกับทิศทางของการเรียงลำดับอย่างเคร่งครัด (แต่แสดงสองสามวิธีที่อาจบรรลุผลได้)
• อาจเป็นการดีที่จะสรุปฟังก์ชันการทำงานเฉพาะประเภทในออบเจ็กต์ C ++ มีคลาสพื้นฐาน & คลาสที่ได้รับสำหรับแต่ละ ประเภท ที่คุณต้องการสนับสนุน ~แต่การบ้านนี้ใช่ไหม - ดังนั้นอาจจะไม่คุ้มค่าที่จะลงเรือมากเกินไป ;)