将字符‘123’转换成整型，浮点型行，复数，并输出

在Python中，将字符串转换为整型、浮点型和复数需要使用不同的函数。以下是示例：

1. **转整型（int）**：

char_str = '123'
int_val = int(char_str)  # 假设输入的是正数值
print("转换为整型：", int_val)

输出：

转换为整型： 123

2. **转浮点型（float）**：

float_val = float(char_str)
print("转换为浮点型：", float_val)

输出：

转换为浮点型： 123.0

3. **转复数（complex）**：

complex_str = '1+2j'  # 因为默认不支持直接将数字字符串转为复数，需要明确指定形式
complex_num = complex(char_str)
print("转换为复数（假设输入的是标准格式）：", complex_num)

输出：

转换为复数（假设输入的是标准格式）： (1+2j)

注意：如果你尝试直接将非数字字符串如 `'abc'` 转换为整型或浮点型，将会抛出异常。

相关问题

定义整型、实型、字符型、布尔型、复数型变量并输出

在C语言中，整型、实型、字符型、布尔型和复数型变量分别有不同的定义方式，下面是一个简单的示例，用于定义并输出这些类型的变量：

#include <stdio.h>
#include <stdbool.h> // 对于布尔型的支持

int main() {
    // 整型变量
    int integerVar = 10;
    
    // 实型（浮点型）变量，分为float和double类型
    float realVar = 10.5f; // float类型
    double doubleVar = 10.5; // double类型，默认的浮点类型
    
    // 字符型变量，使用单引号定义单个字符
    char charVar = 'A';
    
    // 布尔型变量，C99标准中引入，使用stdbool.h头文件
    bool booleanVar = true;
    
    // 复数型变量，C99标准中引入，使用complex.h头文件
    double complex complexVar = 3.0 + 4.0 * I; // I为虚部单位
    
    // 输出变量
    printf("整型变量值：%d\n", integerVar);
    printf("实型变量（float）值：%f\n", realVar);
    printf("实型变量（double）值：%lf\n", doubleVar);
    printf("字符型变量值：%c\n", charVar);
    printf("布尔型变量值：%d\n", booleanVar); // 在C语言中，true通常表示为1
    printf("复数型变量值：%f + %fi\n", creal(complexVar), cimag(complexVar)); // 使用creal()和cimag()函数获取复数的实部和虚部

    return 0;
}

在上述代码中，我们定义了整型、实型（单精度和双精度浮点型）、字符型、布尔型和复数型变量，并使用`printf`函数将它们的值输出到控制台。

1．设计一个程序，将加法运算符和减法运算符分别重载为成员函数，使之能够实现复数的加法运算与减法运算。将乘法运算符和除法运算符分别重载为友元函数，使之能够实现复数的乘法运算与除法运算。 2. 定义一个学生（Student）类，包括学号（整型）、性别（字符型）、姓名（字符串类型）、成绩（浮点型）四个数据成员，编程实现对流插入运算符（<<）和流提取符（>>）的重载，使它们能够对Student类对象直接进行输入和输出。 3.声明抽象基类Shape，由它派生出5个图形类；Circle(圆形)、Square（正方形）、Rectangle（矩形）、Trapezoid（梯形）、Triangle（三角形），用虚函数分别计算几种图形的面积，并求它们的和。要求用基类指针数组，使它的每一个元素指向一个派生类对象。

1. 复数类的加减乘除运算符重载代码如下：

#include <iostream>
using namespace std;

class Complex {
private:
    double real;
    double imag;
public:
    Complex(double r = 0, double i = 0) : real(r), imag(i) {}
    Complex operator+(const Complex& c) const;
    Complex operator-(const Complex& c) const;
    friend Complex operator*(const Complex& c1, const Complex& c2);
    friend Complex operator/(const Complex& c1, const Complex& c2);
    friend ostream& operator<<(ostream& os, const Complex& c);
};

Complex Complex::operator+(const Complex& c) const {
    return Complex(real + c.real, imag + c.imag);
}

Complex Complex::operator-(const Complex& c) const {
    return Complex(real - c.real, imag - c.imag);
}

Complex operator*(const Complex& c1, const Complex& c2) {
    return Complex(c1.real * c2.real - c1.imag * c2.imag, c1.real * c2.imag + c1.imag * c2.real);
}

Complex operator/(const Complex& c1, const Complex& c2) {
    double denominator = c2.real * c2.real + c2.imag * c2.imag;
    return Complex((c1.real * c2.real + c1.imag * c2.imag) / denominator, (c1.imag * c2.real - c1.real * c2.imag) / denominator);
}

ostream& operator<<(ostream& os, const Complex& c) {
    os << "(" << c.real << ", " << c.imag << "i)";
    return os;
}

int main() {
    Complex c1(1, 2), c2(3, 4);
    cout << c1 + c2 << endl; // (4, 6i)
    cout << c1 - c2 << endl; // (-2, -2i)
    cout << c1 * c2 << endl; // (-5, 10i)
    cout << c1 / c2 << endl; // (0.44, -0.08i)
    return 0;
}

2. 学生类的流插入运算符和流提取符重载代码如下：

#include <iostream>
#include <string>
using namespace std;

class Student {
private:
    int id;
    char gender;
    string name;
    double score;
public:
    Student(int i = 0, char g = 'F', string n = "", double s = 0) : id(i), gender(g), name(n), score(s) {}
    friend ostream& operator<<(ostream& os, const Student& s);
    friend istream& operator>>(istream& is, Student& s);
};

ostream& operator<<(ostream& os, const Student& s) {
    os << s.id << " " << s.gender << " " << s.name << " " << s.score;
    return os;
}

istream& operator>>(istream& is, Student& s) {
    is >> s.id >> s.gender >> s.name >> s.score;
    return is;
}

int main() {
    Student s(123, 'F', "Alice", 89.5);
    cout << s << endl; // 123 F Alice 89.5
    Student t;
    cin >> t;
    cout << t << endl;
    return 0;
}

3. 图形类的面积计算和基类指针数组代码如下：

#include <iostream>
using namespace std;

class Shape {
public:
    virtual double area() const = 0;
};

class Circle : public Shape {
private:
    double radius;
public:
    Circle(double r = 0) : radius(r) {}
    virtual double area() const {
        return 3.14159 * radius * radius;
    }
};

class Square : public Shape {
private:
    double side;
public:
    Square(double s = 0) : side(s) {}
    virtual double area() const {
        return side * side;
    }
};

class Rectangle : public Shape {
private:
    double length;
    double width;
public:
    Rectangle(double l = 0, double w = 0) : length(l), width(w) {}
    virtual double area() const {
        return length * width;
    }
};

class Trapezoid : public Shape {
private:
    double top;
    double bottom;
    double height;
public:
    Trapezoid(double t = 0, double b = 0, double h = 0) : top(t), bottom(b), height(h) {}
    virtual double area() const {
        return (top + bottom) * height / 2;
    }
};

class Triangle : public Shape {
private:
    double base;
    double height;
public:
    Triangle(double b = 0, double h = 0) : base(b), height(h) {}
    virtual double area() const {
        return base * height / 2;
    }
};

int main() {
    Shape* shapes[5];
    shapes[0] = new Circle(2);
    shapes[1] = new Square(3);
    shapes[2] = new Rectangle(4, 5);
    shapes[3] = new Trapezoid(2, 4, 3);
    shapes[4] = new Triangle(2, 3);

    double totalArea = 0;
    for (int i = 0; i < 5; i++) {
        totalArea += shapes[i]->area();
        delete shapes[i];
    }

    cout << "Total area: " << totalArea << endl;

    return 0;
}