（C语言）虚数运算（结构体教程）（指针解法）（C语言教程）

双叶8362025-04-03 1:37
cpp 复制代码 
#include <stdio.h>
//定义结构体
typedef struct 
{
    float realpart;
    float imagpart;
}Complex;
//初始化虚数
//传递值，和指针分开
void assign(const float real,const float imag,Complex* A){
    A->imagpart=imag;
    A->realpart=real;
}
//虚数相加
//同样传递值，和指针分开
void add(const Complex A,const Complex B,Complex* C){
    C->imagpart=A.imagpart+B.imagpart;
    C->realpart=A.realpart+B.realpart;
}
//虚数相减
void minus(const Complex A,const Complex B,Complex* C){
    C->imagpart=A.imagpart-B.imagpart;
    C->realpart=A.realpart-B.realpart;
}

//虚数相乘
void multiply(const Complex A,const Complex B,Complex* C){
    C->realpart = A.realpart * B.realpart - A.imagpart * B.imagpart;
    C->imagpart = A.realpart * B.imagpart + A.imagpart * B.realpart;
}
//虚数相除
void divide(const Complex A, const Complex B, Complex* C) {
    Complex conjugate = {B.realpart, -B.imagpart};  // B的共轭
    Complex numerator;
    multiply(A, conjugate,&numerator);            // 分子：A * B的共轭
    float denominator = B.realpart * B.realpart + B.imagpart * B.imagpart;  // 分母
    C->realpart = numerator.realpart / denominator;
    C->imagpart = numerator.imagpart / denominator;
}
//主函数
int main(){

    Complex z1;
    Complex z2;
    Complex z3;

    assign(3.0,4.0,&z1);
    assign(2.0,5.0,&z2);

    add(z1,z2,&z3);
    printf("相加时z3= %.2f + %.2fi\n", z3.realpart, z3.imagpart);

    minus(z1,z2,&z3);
    printf("相减时z3= %.2f + %.2fi\n", z3.realpart, z3.imagpart);

    multiply(z1,z2,&z3);
    printf("相乘时z3= %.2f + %.2fi\n", z3.realpart, z3.imagpart);
    
    divide(z1,z2,&z3);
    printf("相除时z3= %.2f + %.2fi\n", z3.realpart, z3.imagpart);
    return 0;
}

一、结构体定义与初始化

1.1 结构体定义
复制代码 
typedef struct {
    float realpart;
    float imagpart;
} Complex;

  • 知识点解析：

    • typedef的作用 ：为匿名结构体创建别名Complex，简化变量声明。

      复制代码 
      // 无typedef的传统写法
struct Complex { ... };
struct Complex z1;  // 必须带struct

// 有typedef的现代写法
typedef struct { ... } Complex;
Complex z1;         // 直接使用别名

    • 结构体成员 ：realpart（实部）和imagpart（虚部）均为float类型。

    • 内存布局 ：结构体成员在内存中连续存储，总大小为各成员大小之和（此处为2 * sizeof(float) = 8字节）。

1.2 assign函数：初始化复数
复制代码 
void assign(const float real, const float imag, Complex* A) {
    A->imagpart = imag;
    A->realpart = real;
}

  • 知识点解析：

    • 指针操作 ：通过指针A直接修改结构体成员，避免值传递的开销。

    • const关键字 ：保护输入参数real和imag不被意外修改。

    • 操作符-> ：等价于(*A).imagpart，通过指针访问成员。

    • 初始化示例：

      复制代码 
      Complex z1;
assign(3.0, 4.0, &z1);  // z1 = 3.0 + 4.0i

二、复数运算函数

2.1 加法函数add
复制代码 
void add(const Complex A, const Complex B, Complex* C) {
    C->imagpart = A.imagpart + B.imagpart;
    C->realpart = A.realpart + B.realpart;
}

  • 知识点解析：

    • 值传递与指针传递 ：输入参数A和B为值传递（拷贝），输出参数C为指针传递（直接修改目标内存）。

    • const保护输入参数 ：确保函数内不会修改A和B的值。

    • 示例计算：

      复制代码 
      Complex z1 = {3, 4}, z2 = {2, 5}, result;
add(z1, z2, &result);  // result = 5.0 + 9.0i
2.2 减法函数minus
复制代码 
void minus(const Complex A, const Complex B, Complex* C) {
    C->imagpart = A.imagpart - B.imagpart;
    C->realpart = A.realpart - B.realpart;
}

  • 知识点扩展：

    • 函数命名规范 ：minus是动词，符合"动作+参数"的命名习惯（如calculateDifference）。
2.3 乘法函数multiply
复制代码 
void multiply(const Complex A, const Complex B, Complex* C) {
    C->realpart = A.realpart * B.realpart - A.imagpart * B.imagpart;
    C->imagpart = A.realpart * B.imagpart + A.imagpart * B.realpart;
}

  • 数学原理 ：

    复数乘法公式：

    (a+bi)(c+di)=(ac−bd)+(ad+bc)i(a+bi)(c+di)=(ac−bd)+(ad+bc)i

2.4 除法函数divide
复制代码 
void divide(const Complex A, const Complex B, Complex* C) {
    Complex conjugate = {B.realpart, -B.imagpart};  // 共轭复数
    Complex numerator;
    multiply(A, conjugate, &numerator);             // 分子 = A * B的共轭
    float denominator = B.realpart * B.realpart + B.imagpart * B.imagpart;
    C->realpart = numerator.realpart / denominator;
    C->imagpart = numerator.imagpart / denominator;
}

  • 数学原理 ：

    复数除法公式：

    a+bic+di=(a+bi)(c−di)c2+d2c+dia+bi​=c2+d2(a+bi)(c−di)​

三、主函数与代码执行

复制代码 
int main() {
    Complex z1, z2, z3;

    assign(3.0, 4.0, &z1);  // z1 = 3.0 + 4.0i
    assign(2.0, 5.0, &z2);  // z2 = 2.0 + 5.0i

    add(z1, z2, &z3);
    printf("相加结果: %.2f + %.2fi\n", z3.realpart, z3.imagpart);

    minus(z1, z2, &z3);
    printf("相减结果: %.2f + %.2fi\n", z3.realpart, z3.imagpart);

    multiply(z1, z2, &z3);
    printf("相乘结果: %.2f + %.2fi\n", z3.realpart, z3.imagpart);

    divide(z1, z2, &z3);
    printf("相除结果: %.2f + %.2fi\n", z3.realpart, z3.imagpart);

    return 0;
}

  • 输出示例：

    复制代码 
    相加结果: 5.00 + 9.00i
相减结果: 1.00 - 1.00i
相乘结果: -14.00 + 23.00i
相除结果: 0.90 - 0.24i

四、结构体高级知识点扩展

4.1 结构体嵌套
复制代码 
typedef struct {
    int x;
    int y;
} Point;

typedef struct {
    Point start;
    Point end;
} Line;

  • 示例用法：

    复制代码 
    Line line = {{0, 0}, {3, 4}};
printf("线段长度: %.2f\n", sqrt(pow(line.end.x - line.start.x, 2) + 
                                pow(line.end.y - line.start.y, 2)));
4.2 结构体与动态内存
复制代码 
Complex* createComplex(float real, float imag) {
    Complex* c = (Complex*)malloc(sizeof(Complex));
    if (c != NULL) {
        c->realpart = real;
        c->imagpart = imag;
    }
    return c;
}

// 使用后需手动释放内存
Complex* z = createComplex(3.0, 4.0);
free(z);
4.3 结构体对齐与填充

  • 对齐规则：结构体成员按最大成员类型的对齐要求排列。

    复制代码 
    struct Example {
    char a;      // 1字节
    int b;       // 4字节（对齐到4的倍数地址）
    double c;    // 8字节（对齐到8的倍数地址）
};
// 总大小: 1 + 3（填充） + 4 + 8 = 16字节
4.4 结构体位域
复制代码 
typedef struct {
    unsigned int isReady : 1;  // 1位
    unsigned int hasError : 1;
    unsigned int status  : 4;  // 4位
} DeviceStatus;

五、总结

  • 核心知识点：

    • 结构体封装数据，函数模拟方法，实现面向对象风格。

    • 指针传递提升效率，const保护数据安全。

    • 复数运算需严格遵循数学公式。

  • 扩展应用：

    • 结构体嵌套、动态内存管理、位域操作等高级用法。

    • 结合文件操作、网络通信等场景设计复杂数据结构。

通过结构体和函数的组合，C语言能够有效模拟对象的行为，为底层系统开发和嵌入式编程提供灵活的数据管理能力。

解释完代码后，下面来介绍一下结构体，在之前，我们简单的介绍过结构体，今天来详细介绍并举例说明：

结构体相关介绍（详细）

1. 什么是结构体？

结构体（struct）是C语言中一种自定义的复合数据类型，它允许你将多个不同类型的数据组合在一起，形成一个新的数据类型。

通俗理解：就像是一个"盒子"，里面可以放各种不同类型的东西（数据）。

2. 为什么要用结构体？

想象你要记录一个学生的信息：

  • 姓名（字符串）

  • 年龄（整数）

  • 成绩（浮点数）

如果没有结构体，你需要这样：

复制代码 
char name[20];
int age;
float score;

有了结构体，你可以把它们打包成一个整体：

复制代码 
struct Student {
    char name[20];
    int age;
    float score;
};

3. 结构体的基本语法

3.1 定义结构体

复制代码 
struct 结构体名 {
    数据类型 成员1;
    数据类型 成员2;
    // ...
};

示例：

复制代码 
// 定义一个表示点的结构体
struct Point {
    int x;  // x坐标
    int y;  // y坐标
};

3.2 使用typedef简化

每次使用结构体都要写struct关键字很麻烦，可以用typedef简化：

复制代码 
typedef struct {
    int x;
    int y;
} Point;  // 现在可以直接用Point声明变量

3.3 声明结构体变量

复制代码 
// 方法1：定义时直接声明
struct Student {
    char name[20];
    int age;
} stu1, stu2;

// 方法2：先定义后声明
struct Student stu3;

// 使用typedef后更简单
Point p1, p2;

3.4 初始化结构体

复制代码 
// 方法1：按顺序初始化
struct Student stu1 = {"张三", 18, 90.5};

// 方法2：指定成员初始化（C99标准）
struct Student stu2 = {.name = "李四", .age = 19, .score = 88.5};

// 使用typedef的初始化
Point p1 = {10, 20};

4. 访问结构体成员

使用点运算符.访问结构体成员：

复制代码 
struct Student stu1 = {"张三", 18, 90.5};
printf("姓名：%s\n", stu1.name);
printf("年龄：%d\n", stu1.age);
printf("成绩：%.1f\n", stu1.score);

// 修改成员值
stu1.age = 19;

5. 结构体指针

当结构体很大时，直接传递结构体会产生拷贝开销，这时可以使用指针：

复制代码 
struct Student stu1 = {"张三", 18, 90.5};
struct Student *pStu = &stu1;

// 通过指针访问成员
printf("姓名：%s\n", (*pStu).name);  // 方法1
printf("姓名：%s\n", pStu->name);    // 方法2（更常用）

箭头运算符->：专门用于通过指针访问结构体成员。

6. 结构体的大小

结构体的大小不是简单等于各成员大小之和，因为存在内存对齐问题：

复制代码 
struct Example1 {
    char a;   // 1字节
    int b;    // 4字节
    double c; // 8字节
};
// 不是1+4+8=13，实际可能是16字节（取决于对齐规则）

可以使用sizeof运算符查看结构体大小：

复制代码 
printf("结构体大小：%zu字节\n", sizeof(struct Example1));

7. 结构体数组

可以创建结构体类型的数组：

复制代码 
struct Student class[3] = {
    {"张三", 18, 90.5},
    {"李四", 19, 88.0},
    {"王五", 17, 92.5}
};

// 访问数组元素
printf("第二个学生的姓名：%s\n", class[1].name);

8. 结构体嵌套

结构体可以包含其他结构体：

复制代码 
typedef struct {
    int hour;
    int minute;
    int second;
} Time;

typedef struct {
    int year;
    int month;
    int day;
    Time time;
} DateTime;

// 初始化
DateTime dt = {2023, 10, 15, {14, 30, 0}};

// 访问嵌套成员
printf("时间是：%d:%d:%d\n", dt.time.hour, dt.time.minute, dt.time.second);

9. 结构体作为函数参数

结构体可以作为函数参数传递：

复制代码 
// 值传递（会产生拷贝）
void printStudent(struct Student stu) {
    printf("姓名：%s\n", stu.name);
    // ...
}

// 指针传递（更高效）
void modifyStudent(struct Student *pStu) {
    pStu->age += 1;
}

// 使用
printStudent(stu1);
modifyStudent(&stu1);

10. 结构体应用实例

10.1 学生管理系统

复制代码 
#include <stdio.h>
#include <string.h>

typedef struct {
    char name[20];
    int age;
    float score;
} Student;

void inputStudent(Student *stu) {
    printf("请输入姓名：");
    scanf("%s", stu->name);
    printf("请输入年龄：");
    scanf("%d", &stu->age);
    printf("请输入成绩：");
    scanf("%f", &stu->score);
}

void printStudent(Student stu) {
    printf("姓名：%s\n", stu.name);
    printf("年龄：%d\n", stu.age);
    printf("成绩：%.1f\n", stu.score);
}

int main() {
    Student stu;
    inputStudent(&stu);
    printStudent(stu);
    return 0;
}

10.2 图形计算

复制代码 
#include <stdio.h>
#include <math.h>

typedef struct {
    double x;
    double y;
} Point;

double distance(Point p1, Point p2) {
    return sqrt(pow(p1.x - p2.x, 2) + pow(p1.y - p2.y, 2));
}

int main() {
    Point a = {0, 0};
    Point b = {3, 4};
    printf("两点距离：%.2f\n", distance(a, b));
    return 0;
}

11. 常见问题

11.1 结构体赋值

结构体可以直接赋值（C语言支持）：

复制代码 
Point p1 = {10, 20};
Point p2;
p2 = p1;  // 合法，会复制所有成员的值

11.2 结构体比较

不能直接用==比较结构体，需要逐个比较成员：

复制代码 
int isEqual(Point p1, Point p2) {
    return p1.x == p2.x && p1.y == p2.y;
}

11.3 结构体动态分配

可以使用malloc动态创建结构体：

复制代码 
Student *pStu = (Student *)malloc(sizeof(Student));
strcpy(pStu->name, "张三");
pStu->age = 18;
// 使用完后记得释放
free(pStu);

12. 总结

结构体是C语言中非常重要的特性，它允许你将相关的数据组合在一起，使代码更加清晰和易于维护。记住以下几点：

  1. 使用struct定义结构体，可以用typedef简化

  2. 用.访问成员，用->通过指针访问成员

  3. 结构体可以作为函数参数传递（值传递或指针传递）

  4. 结构体支持嵌套和数组

  5. 理解结构体的内存对齐规则

通过大量练习，你会逐渐掌握结构体的使用技巧。尝试用结构体来解决实际问题，比如学生管理系统、图书管理系统等，这将帮助你更好地理解结构体的强大之处。

学生管理系统：

（C语言）学生信息表（学生管理系统）（基于通讯录改版）（正式版）（C语言项目）-CSDN博客

运算结果如下：

cpp 复制代码 
相加时z3= 5.00 + 9.00i
相减时z3= 1.00 + -1.00i
相乘时z3= -14.00 + 23.00i
相除时z3= 0.90 + -0.24i

请按任意键继续. . .
相关推荐
香蕉可乐荷包蛋27 分钟前
Python面试问题
开发语言·python·面试
Vacant Seat32 分钟前
贪心算法-跳跃游戏II
算法·游戏·贪心算法
小柒的博客34 分钟前
联合体union的特殊之处
c语言·机器人
ErizJ36 分钟前
Golang｜分布式索引架构
开发语言·分布式·后端·架构·golang
.生产的驴37 分钟前
SpringBoot 接口国际化i18n 多语言返回 中英文切换 全球化 语言切换
java·开发语言·spring boot·后端·前端框架
夜松云41 分钟前
从对数变换到深度框架：逻辑回归与交叉熵的数学原理及PyTorch实战
pytorch·算法·逻辑回归·梯度下降·交叉熵·对数变换·sigmoid函数
杨筱毅43 分钟前
【优秀三方库研读】【性能优化点滴】odygrd/quill 解决伪共享
c++·性能优化·三方库研读
八股文领域大手子1 小时前
深入浅出限流算法（三）：追求极致精确的滑动日志
开发语言·数据结构·算法·leetcode·mybatis·哈希算法
新时代苦力工1 小时前
处理对象集合，输出Map＜String, Map＜String, List＜MyObject＞＞＞格式数据，无序组合键处理方法
java·数据结构·list
啊阿狸不会拉杆1 小时前
人工智能数学基础（一）：人工智能与数学
人工智能·python·算法
热门推荐
01西电B测-计算机网络综合实验(含验收问题)02KGG转MP3工具|非KGM文件|解密音频03从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑04Coze扣子平台完整体验和实践（附国内和国际版对比）05YOLOv8入门 | 重要性能衡量指标、训练结果评价及分析及影响mAP的因素【发论文关注的指标】06DeepSeek各版本说明与优缺点分析07最新 Kubernetes 集群部署 + flannel 网络插件（保姆级教程，最新 K8S 版本）08yolov8，yolo11，yolo12 服务器训练到部署全流程 笔记09我决定放弃搞 Java 了10yolov10来了！用yolov10训练自己的数据集（原理、训练、部署、应用）