def strQ2B(ustring): rstring = "" for uchar in ustring: inside_code = ord(uchar) if inside_code == 12288: inside_code = 32 elif 65281 <= inside_code <= 65374: inside_code -= 65248 rstring += chr(inside_code) return rstring

这段代码的功能是将字符串中的全角字符转换为半角字符。全角字符是指Unicode编码值大于等于65281的字符，半角字符是指Unicode编码值小于等于126的字符。在转换过程中，将全角空格（Unicode编码值为12288）转换为半角空格（Unicode编码值为32），将其他全角字符的Unicode编码值减去65248，得到对应的半角字符的Unicode编码值。最后将转换后的字符拼接成新的字符串并返回。

相关问题

#include <iostream> using namespace std; #include<string> #include"math.h" template<class T> class vlist//线性表抽象类 { public: virtual void in(T &e)=0; virtual T out()=0; }; template<class T> class Element//线性表存储元素 { public: T data; Element<T> next; Element(){} }; //在beign和end之间完成SStack和Quene类的定义及实现，其继承vlist /begin/ /end***/ int main() { vlist<int> *intp; vlist<string> *strp; SStack<int> ints; Quene<int> intq; SStack<string> strs; Quene<string> strq; intp=&ints; int t=2; intp->in(t); t=3; intp->in(t); t=4; intp->in(t); for(int i=0;i<3;i++) cout<<intp->out(); intp=&intq; t=2; intp->in(t); t=3; intp->in(t); t=4; intp->in(t); for(int i=0;i<3;i++) cout<<intp->out(); strp=&strs; string str; cout<<endl; for(int i=0;i<3;i++) { cin>>str; strp->in(str); } for(int i=0;i<3;i++) cout<<strp->out()<<" "; cout<<endl; strp=&strq; for(int i=0;i<3;i++) { cin>>str; strp->in(str); } for(int i=0;i<3;i++) cout<<strp->out()<<" "; }补充代码

以下是SStack和Quene类的定义及实现：

template<class T>
class SStack: public vlist<T>//栈
{
    Element<T> *head;
public:
    SStack(){head=new Element<T>();}
    void in(T &e){Element<T> *p=new Element<T>();p->next=head->next;head->next=p;p->data=e;}
    T out(){Element<T> *p=head->next;T e=p->data;head->next=p->next;delete p;return e;}
};

template<class T>
class Quene: public vlist<T>//队列
{
    Element<T> *head,*tail;
public:
    Quene(){head=tail=new Element<T>();}
    void in(T &e){Element<T> *p=new Element<T>();tail->next=p;tail=p;p->data=e;}
    T out(){Element<T> *p=head->next;T e=p->data;head->next=p->next;if(!head->next)tail=head;delete p;return e;}
};

c++设置一个vlist线性表类，抽象函数in(),out()，表示进表和出表，由Stack类和Quene类继承vlist，实现vlist指针既能是栈也可以是队列的功能。同时还可对不同的数据类型进行进表和出表。 并补充以下代码： #include <iostream> using namespace std; #include<string> #include"math.h" template<class T> class vlist//线性表抽象类 { public: virtual void in(T &e)=0; virtual T out()=0; }; template<class T> class Element { public: T data; Element<T> *next; Element(){} }; int main() { vlist<int> *intp; vlist<string> *strp; SStack<int> ints; Quene<int> intq; SStack<string> strs; Quene<string> strq; intp=&ints; int t=2; intp->in(t); t=3; intp->in(t); t=4; intp->in(t); for(int i=0;i<3;i++) cout<<intp->out(); intp=&intq; t=2; intp->in(t); t=3; intp->in(t); t=4; intp->in(t); for(int i=0;i<3;i++) cout<<intp->out(); strp=&strs; string str; cout<<endl; for(int i=0;i<3;i++) { cin>>str; strp->in(str); } for(int i=0;i<3;i++) cout<<strp->out()<<" "; cout<<endl; strp=&strq; for(int i=0;i<3;i++) { cin>>str; strp->in(str); } for(int i=0;i<3;i++) cout<<strp->out()<<" "; }

好的，这是一个比较典型的面向对象的编程题目。我根据题目描述，补充了一下代码，希望可以帮到你：

#include <iostream>
#include <string>
#include <cmath>

using namespace std;

template <class T>
class Element {
public:
    T data;
    Element<T> *next;
    Element() {
        next = NULL;
    }
};

template <class T>
class vlist//线性表抽象类
{
public:
    virtual void in(T &e) = 0;
    virtual T out() = 0;
};

template <class T>
class SStack : public vlist<T> {
public:
    Element<T> *top;
    SStack() {
        top = NULL;
    }
    void in(T &e) {
        Element<T> *p = new Element<T>();
        p->data = e;
        p->next = top;
        top = p;
    }
    T out() {
        T e = top->data;
        Element<T> *p = top;
        top = top->next;
        delete p;
        return e;
    }
};

template <class T>
class Quene : public vlist<T> {
public:
    Element<T> *head;
    Element<T> *tail;
    Quene() {
        head = tail = NULL;
    }
    void in(T &e) {
        Element<T> *p = new Element<T>();
        p->data = e;
        if (tail == NULL) {
            head = tail = p;
        } else {
            tail->next = p;
            tail = p;
        }
    }
    T out() {
        T e = head->data;
        Element<T> *p = head;
        head = head->next;
        delete p;
        if (head == NULL) {
            tail = NULL;
        }
        return e;
    }
};

int main() {
    vlist<int> *intp;
    vlist<string> *strp;
    SStack<int> ints;
    Quene<int> intq;
    SStack<string> strs;
    Quene<string> strq;
    intp = &ints;
    int t = 2;
    intp->in(t);
    t = 3;
    intp->in(t);
    t = 4;
    intp->in(t);
    for (int i = 0; i < 3; i++) {
        cout << intp->out() << " ";
    }
    intp = &intq;
    t = 2;
    intp->in(t);
    t = 3;
    intp->in(t);
    t = 4;
    intp->in(t);
    for (int i = 0; i < 3; i++) {
        cout << intp->out() << " ";
    }
    strp = &strs;
    string str;
    cout << endl;
    for (int i = 0; i < 3; i++) {
        cin >> str;
        strp->in(str);
    }
    for (int i = 0; i < 3; i++) {
        cout << strp->out() << " ";
    }
    cout << endl;
    strp = &strq;
    for (int i = 0; i < 3; i++) {
        cin >> str;
        strp->in(str);
    }
    for (int i = 0; i < 3; i++) {
        cout << strp->out() << " ";
    }
    return 0;
}

这个程序中，我们首先定义了一个抽象类 `vlist`，它包含了两个纯虚函数 `in()` 和 `out()`，表示线性表的进表和出表操作。然后，我们定义了两个类 `SStack` 和 `Quene` 分别继承了 `vlist` 类，实现了栈和队列的功能。

在 `SStack` 类中，我们使用一个指针 `top` 来表示栈顶元素。在进表操作中，我们创建一个新的元素，并把它放到栈顶，然后更新 `top` 指针。在出表操作中，我们首先取出栈顶元素，然后删除它并更新 `top` 指针。

在 `Quene` 类中，我们使用两个指针 `head` 和 `tail` 分别表示队列头和队列尾。在进表操作中，我们创建一个新的元素，并把它放到队列尾部，然后更新 `tail` 指针。在出表操作中，我们首先取出队列头元素，然后删除它并更新 `head` 指针。如果此时队列为空，我们还需要把 `tail` 指针设置为 `NULL`。

最后，我们在 `main` 函数中创建了四个对象：`ints`、`intq`、`strs` 和 `strq`，并把它们赋值给对应的指针。然后，我们分别进行了进表和出表操作，并输出了结果。

希望这个答案能够帮到你！