C语言求解两点间距离用结构体和函数

在C语言中，为了求解两点之间的距离，我们通常会使用二维坐标系，并创建一个结构体来表示点的位置。首先，我们可以定义一个名为`Point`的结构体，包含两个成员变量，例如`x`和`y`，代表横纵坐标：

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

接下来，编写一个函数`distance_between_points`来计算两个`Point`类型的结构体之间的欧几里得距离。这个函数接收两个`Point`类型的参数并返回一个`double`类型的值：

double distance_between_points(Point p1, Point p2) {
    double dx = p1.x - p2.x;
    double dy = p1.y - p2.y;
    return sqrt(dx * dx + dy * dy);
}

这里我们假设你知道如何使用math.h库中的`sqrt`函数，它用于计算平方根。

使用这个函数的方式就像这样：

Point pointA = {5, 3};
Point pointB = {10, 7};

double dist = distance_between_points(pointA, pointB);
printf("The distance between point A and B is %.2f\n", dist);

相关问题

c语言编程求解：定义一个结构体变量（包括年、月、日）。用函数countdays实现计算该日在本年中是第几天，并计算该年份是否闰年。要求由主函数将年、月、日传递给countdays函数，计算后将日数传回主函数输出。

以下是一个C语言的示例代码，用于计算给定日期在本年中是第几天，并判断该年份是否为闰年：

#include <stdio.h>

struct Date {
    int year;
    int month;
    int day;
};

int isLeapYear(int year) {
    if ((year % 4 == 0 && year % 100 ! 0) || year % 400 == 0) {
        return 1; // 是闰年
    } else {
        return 0; // 不是闰年
    }
}

int countDays(struct Date date) {
    int daysInMonth[] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
    int days = 0;
    
    for (int i = 1; i < date.month; i++) {
        days += daysInMonth[i];
    }
    
    days += date.day;
    
    if (isLeapYear(date.year) && date.month > 2) {
        days += 1;
    }
    
    return days;
}

int main() {
    struct Date date;
    
    printf("请输入年份：");
    scanf("%d", &date.year);
    
    printf("请输入月份：");
    scanf("%d", &date.month);
    
    printf("请输入日期：");
    scanf("%d", &date.day);
    
    int days = countDays(date);
    
    printf("该日在本年中是第%d天\n", days);
    
    if (isLeapYear(date.year)) {
        printf("该年份是闰年\n");
    } else {
        printf("该年份不是闰年\n");
    }
    
    return 0;
}

使用C语言求解first集合和follow集合

求解一个文法的 FIRST 集合和 FOLLOW 集合是编译原理中的重要内容之一。下面提供一些简单的代码来演示如何使用 C 语言求解 FIRST 集合和 FOLLOW 集合。

首先，我们需要定义一个结构体来表示一个终结符或非终结符。

typedef struct {
    int is_terminal;  // 是否为终结符，0 表示非终结符，1 表示终结符
    char symbol;      // 符号名称
} Symbol;

然后，我们需要定义一个函数来计算一个产生式的 FIRST 集合。

void compute_first_set(Symbol* production, int length, Symbol* first_set) {
    int i;
    for (i = 0; i < length; i++) {
        if (production[i].is_terminal) {  // 如果是终结符，将其加入 FIRST 集合
            add_to_set(first_set, production[i]);
            break;
        } else {  // 如果是非终结符，计算其 FIRST 集合
            compute_first_set(get_production(production[i]), get_production_length(production[i]), first_set);
            if (!has_epsilon(get_production(production[i]))) {  // 如果该非终结符不能推导出空串，退出循环
                break;
            }
        }
    }
}

上面的代码中，`production` 表示一个产生式，`length` 表示该产生式的长度，`first_set` 表示该产生式的 FIRST 集合。

函数中，我们遍历产生式中的每一个符号，如果是终结符，将其加入 FIRST 集合；如果是非终结符，计算其 FIRST 集合，并判断是否能够推导出空串。如果不能推导出空串，退出循环。

接下来，我们需要定义一个函数来计算一个非终结符的 FOLLOW 集合。

void compute_follow_set(Symbol* symbol, Symbol* follow_set) {
    int i, j;
    Symbol* production;
    int length;
    int index_of_symbol;

    if (is_start_symbol(symbol)) {  // 如果该非终结符是文法的起始符号，将 $ 加入其 FOLLOW 集合
        add_to_set(follow_set, create_terminal_symbol('$'));
    }

    for (i = 0; i < get_production_count(); i++) {  // 遍历文法的所有产生式
        production = get_production_by_index(i);
        length = get_production_length(production);
        index_of_symbol = find_symbol_in_production(symbol, production, length);
        if (index_of_symbol >= 0 && index_of_symbol < length - 1) {  // 如果该非终结符在产生式中，并且不是最后一个符号
            compute_first_set(production + index_of_symbol + 1, length - index_of_symbol - 1, follow_set);  // 计算其后面符号的 FIRST 集合
            for (j = 0; j < length - index_of_symbol - 1; j++) {  // 将其后面符号的 FIRST 集合加入其 FOLLOW 集合
                if (has_epsilon(production[index_of_symbol + j + 1])) {
                    continue;
                }
                add_to_set(follow_set, production[index_of_symbol + j + 1]);
            }
        } else if (index_of_symbol == length - 1) {  // 如果该非终结符是产生式的最后一个符号
            compute_follow_set(get_left_symbol(production), follow_set);  // 计算其左侧非终结符的 FOLLOW 集合，并将其加入其 FOLLOW 集合
            merge_set(follow_set, get_follow_set(get_left_symbol(production)));
        }
    }
}

上面的代码中，`symbol` 表示一个非终结符，`follow_set` 表示该非终结符的 FOLLOW 集合。

函数中，我们首先判断该非终结符是否为文法的起始符号，如果是，将 `$` 加入其 FOLLOW 集合。

然后，遍历文法的所有产生式，找到包含该非终结符的产生式。如果该非终结符不是产生式的最后一个符号，计算其后面符号的 FIRST 集合，并将其加入其 FOLLOW 集合。如果该非终结符是产生式的最后一个符号，计算其左侧非终结符的 FOLLOW 集合，并将其加入其 FOLLOW 集合。

最后，我们可以调用上述函数来求解某个文法的 FIRST 集合和 FOLLOW 集合。

int main() {
    init_grammar();  // 初始化文法
    compute_all_first_sets();  // 计算文法的所有产生式的 FIRST 集合
    compute_all_follow_sets();  // 计算文法的所有非终结符的 FOLLOW 集合
    print_all_first_sets();  // 输出文法的所有产生式的 FIRST 集合
    print_all_follow_sets();  // 输出文法的所有非终结符的 FOLLOW 集合
    return 0;
}