Memasukkan elemen yang tipenya tidak diketahui ke dalam vektor

C++ adalah bahasa yang diketik secara statis. Artinya semua tipe harus ditentukan selama kompilasi: Anda tidak dapat memasukkan tipe baru saat menjalankan program.

• membuat vektor tipe void (jelas tidak diperbolehkan sekarang karena saya sudah menelitinya, ups)

void sebenarnya adalah tipe yang cukup aneh, sebagian besar merupakan pengganti ketika Anda mengharapkan suatu tipe (seperti tipe pengembalian fungsi) dan tidak ada yang disediakan. void* digunakan sebagai penunjuk ke tipe yang tidak diketahui (kebanyakan dalam C) tapi ini cukup meretas, karena informasi tentang dokumen asli dibuang (sejauh menyangkut bahasa) sehingga hal ini menyebabkan masalah untuk benar-benar melakukan sesuatu dengan nilai tersebut jadi diperoleh.

• membebani fungsi yang disebut insertInVector dengan mengirimkan elemen pertama ke fungsi dan membiarkan fungsi menentukan tipe vektor mana yang akan dibuat berdasarkan tipe elemen pertama

• #include <typeinfo> dalam program, mencari tipe elemen pertama, lalu membuat vektor menggunakan vector<typeid(firstElement).name()> dan sejujurnya saya tidak yakin mengapa itu tidak berhasil, tetapi ternyata tidak.

Sayangnya tidak ada yang mungkin: karena Anda tidak dapat mendeklarasikan variabel tanpa tipe, tipe firstElement apa yang akan digunakan untuk memulai?

Masalah yang Anda uraikan secara umum sulit. Pada dasarnya ini berarti Anda harus menerima serangkaian karakter, dan kemudian mengkodekan serangkaian aturan untuk menentukan cara menafsirkan karakter tersebut. Hal ini dilakukan secara umum dengan menggunakan tata bahasa untuk menyandikan aturan-aturan tersebut; tetapi tata bahasanya mungkin rumit untuk tugas yang mungkin sederhana.

Izinkan saya memberikan contoh kecil:

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;
};

Jelas, tantangan sebenarnya adalah Parse input dengan benar.

Idenya adalah dengan menggunakan seperangkat aturan, misalnya:

• sebuah int hanya terdiri dari angka, opsional diawali dengan -
• a double hanya terdiri dari angka, dengan paling banyak satu . dan secara opsional diawali dengan -
• a string bisa apa saja, oleh karena itu adalah tujuan umum kami

Kemudian kita dapat menulis bagian pengenalan dari metode 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

Dan dengan logika tebak-tebakan bersama, akhirnya muncullah parse:

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

Fiuh!

Jadi ? Hampir sampai. Sekarang kita perlu menentukan bagaimana membandingkan dua masukan. Mudah saja jika semuanya memiliki tipe yang sama, jika tidak Anda perlu menentukan logika arbitrer. Anda dapat mengubah input Int menjadi input Double dengan cukup mudah, tetapi untuk string ini sedikit lebih aneh.

// 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<

Dan yang terakhir, programnya:

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;
}

Tentu saja karena saya tidak tahu tipe apa yang ingin Anda hadapi.. Saya telah memutuskan set yang sewenang-wenang;) Namun ini akan memberi Anda kerangka untuk dijadikan dasar.

Melihat persyaratan sebenarnya dari masalah seperti yang dinyatakan dalam komentar, saya sarankan Anda menyimpan semua input dalam std::vector<std::string> dan mengurutkan vektor menggunakan std::sort. Jadi, daripada mengkhawatirkan tipe yang berbeda, Anda dapat menentukan logika pengurutan bergantung pada apa yang Anda tafsirkan untuk mewakili string dalam vektor Anda. Jadi

1. Menerapkan fungsi pengurutan untuk string bergantung pada apa yang diwakili oleh string tersebut (lebih lanjut nanti)
2. menyimpan input sebagai string dalam vektor.
3. Tentukan jenis string yang diwakilinya
4. pilih fungsi penyortiran berdasarkan jenis ini
5. Urutkan vektor menggunakan std::sort dan fungsi pengurutan yang sesuai.

Mengenai fungsi pengurutan, std::sort menerima fungsi atau fungsi biner yang menerapkan perbandingan "kurang dari" pada dua elemen, sehingga fungsi atau fungsi Anda akan terlihat seperti

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

Sunting: Melihat komentar yang lebih baru, tampaknya tujuan utama latihan ini adalah untuk mengimplementasikan algoritma pengurutan untuk tipe yang berbeda. Dalam hal ini, saya akan menyarankan untuk mengikuti pendekatan yang diambil oleh pustaka standar C++, yaitu mengimplementasikan pengurutan berdasarkan istilah atau perbandingan kurang dari antara dua tipe, sehingga memisahkan logika pengurutan dari tipe-tipe tersebut. untuk diurutkan. Jadi, Anda menginginkan fungsi penyortiran templat, berdasarkan tipe iterator dan fungsi/fungsi perbandingan.

Jika Anda mengetahui tipe apa saja yang dapat dimasukkan oleh pengguna, Anda dapat menggunakan templat dan warisan:

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
}

Itu hanya sebuah ide (Input tidak dapat diimplementasikan seperti itu, Anda perlu mengubah bagian itu dengan logika yang mendapatkan sesuatu dari pengguna dan menentukan tipenya), tetapi memiliki manfaat untuk menutupi tipe tersebut ke dalam kelas generik, sehingga Anda bisa faktorkan kode Anda pada antarmuka yang disediakan oleh Generic.

Ide lain (mungkin lebih mudah) adalah menggunakan std::vector<void*> dan enum yang memberi tahu Anda jenis data yang disimpan dalam vektor. Saat Anda perlu memproses data tersebut di suatu tempat di masa mendatang, Anda dapat mengaktifkan enum untuk memasukkan elemen vektor dengan tepat ke tipe yang benar dan mengirimkannya ke kode yang sesuai.

EDIT: ide lainnya adalah mendefinisikan fungsi templat yang mengambil masukan dan mengurutkan array menggunakan pembanding standar:

#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;
}

Logika untuk menentukan jenis input pertama terserah Anda (mungkin bisa membuka pertanyaan lain) ;)

Ada dua aspek untuk pertanyaan ini: penguraian & pengurutan.

• Anda dapat menggunakan ekspresi reguler untuk memeriksa tipe data input pengguna.
• Anda dapat menggunakan cin untuk mengurai data.

Pertama: sadari bahwa Anda tidak harus mengetahui jenis masukan pengguna Anda sampai Anda menerima semuanya ~misalnya: pertimbangkan daftar pengguna nama :

728278243
390349346
495045594
elizabeth

Oleh karena itu, sebaiknya jangan berasumsi bahwa Andalah yang paling tahu tentang data yang masuk (dapat menyebabkan pengalaman pengguna yang membuat frustrasi) namun sebaliknya, lebih memilih untuk memperlakukan semuanya sebagai sebuah string. Simpan semua masukan mentah sebagai string sehingga Anda dapat menghasilkan keluaran dalam format yang sama dengan masukan. Anda dapat menggunakan, katakanlah, tipe yang disebutkan untuk beralih ke dalam pembanding pengurutan atau pertimbangkan untuk menggunakan mutliset/multimap. di sini Anda akan membuat set terurut. jadi tidak perlu disortir. NB: kompleksitas untuk membangun kumpulan N elemen atau yang terurut, untuk satu pengurutan pada N elemen daftar yang tidak disortir, kira-kira setara ~> NlogN

Untuk tugas yang sedang Anda kerjakan, hal ini tidak menjadi masalah, namun pada kenyataannya tergantung pada bagaimana daftar tersebut digunakan, satu pendekatan atau lainnya akan jauh lebih tepat dalam hal kinerja.

Jika Anda sudah pernah menggunakan yang seperti std::vector maka std::multimap seharusnya tidak terlalu menakutkan. Secara longgar, ini adalah rangkaian pasangan nilai kunci yang terkait. multi di sini artinya dapat menyimpan banyak elemen dengan kunci sama (yang Anda inginkan di sini).

Dalam contoh ini saya menggunakan pustaka regex boost untuk menentukan beberapa tipe data masukan funky.
(misalnya: sudo apt-get install libboost-regex1.46-dev)

regex ini mungkin tampak misterius tetapi ada banyak contoh di i/web untuk hampir semua pola yang bisa dibayangkan. [NB: Regex C++11 merupakan pengganti drop-in untuk boost regex. yaitu: boost regex harus kompatibel dengan standar C++11 yang sedang berkembang]

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;
}

Contoh telah dikompilasi & dijalankan di Ubuntu. Hal-hal baris perintah:

$
$ 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
$

NB: Ini contoh kodenya:

• Ada banyak optimasi yang bisa dilakukan di sini. Anda jelas tidak membutuhkan stl container sebanyak yang saya gunakan.
• Saya tidak secara ketat membahas arah hal tersebut (tetapi tunjukkan beberapa cara yang dapat dicapai).
• Mungkin juga bagus untuk merangkum fungsionalitas tipe spesifik dalam objek C++; punya kelas dasar & kemudian kelas turunan untuk setiap jenis yang ingin Anda dukung ~tetapi pekerjaan rumah ini kan? -jadi mungkin tidak layak untuk berlebihan;)