用C语言编写一个程序,要求用到结构体
时间: 2023-03-19 20:22:17 浏览: 88
好的,以下是一个用C语言编写的使用结构体的程序示例:
```c
#include <stdio.h>
// 定义一个结构体
struct student {
char name[20];
int age;
float score;
};
int main() {
// 定义结构体变量并初始化
struct student stu1 = {"张三", 18, 90.5};
// 访问结构体变量成员并输出
printf("姓名:%s,年龄:%d,成绩:%.2f\n", stu1.name, stu1.age, stu1.score);
// 定义结构体指针
struct student *pStu = &stu1;
// 通过指针访问结构体变量成员并输出
printf("姓名:%s,年龄:%d,成绩:%.2f\n", pStu->name, pStu->age, pStu->score);
return 0;
}
```
以上程序定义了一个名为“student”的结构体,其中包含了学生的姓名、年龄和成绩三个成员。在主函数中,首先定义了一个结构体变量stu1并初始化,然后通过点运算符访问结构体成员并输出。接着定义了一个指向结构体的指针pStu,并将其指向stu1,然后通过箭头运算符访问结构体成员并输出。这里需要注意的是,通过指针访问结构体成员时要使用箭头运算符,而不是点运算符。
通过结构体,我们可以将不同的数据类型组合在一起形成一个自定义的数据类型,使得程序更加清晰、简洁。
相关问题
在linux平台用C语言编写一个socket服务端示例代码,要求用到select()函数
好的,以下是一个基于 select() 函数的简单的 C 语言代码示例,用于在 Linux 平台上编写一个 socket 服务端:
```c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <sys/select.h>
#define MAX_CLIENTS 10
int main(){
int server_fd, client_fd, max_fd, activity, i, valread;
int client_sockets[MAX_CLIENTS];
struct sockaddr_in server_addr, client_addr;
socklen_t client_len;
char buffer[1024];
// 创建 socket 对象
server_fd = socket(AF_INET, SOCK_STREAM, 0);
if(server_fd == -1){
perror("socket");
exit(EXIT_FAILURE);
}
// 初始化 server 地址结构体
memset(&server_addr, 0, sizeof(server_addr));
server_addr.sin_family = AF_INET;
server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
server_addr.sin_port = htons(8888);
// 绑定端口号
if(bind(server_fd, (struct sockaddr *)&server_addr, sizeof(server_addr)) == -1){
perror("bind");
exit(EXIT_FAILURE);
}
// 监听端口号
if(listen(server_fd, 5) == -1){
perror("listen");
exit(EXIT_FAILURE);
}
printf("服务器启动,监听端口号:8888\n");
// 初始化客户端 socket 数组
for(i = 0; i < MAX_CLIENTS; i++){
client_sockets[i] = 0;
}
while(1){
fd_set read_fds;
FD_ZERO(&read_fds);
FD_SET(server_fd, &read_fds);
max_fd = server_fd;
// 添加所有客户端 socket 到 read_fds 集合中
for(i = 0; i < MAX_CLIENTS; i++){
client_fd = client_sockets[i];
if(client_fd > 0){
FD_SET(client_fd, &read_fds);
}
if(client_fd > max_fd){
max_fd = client_fd;
}
}
// 使用 select() 函数等待可读事件
activity = select(max_fd + 1, &read_fds, NULL, NULL, NULL);
if(activity == -1){
perror("select");
exit(EXIT_FAILURE);
}
// 如果是服务器 socket 可读,则有新的客户端连接进来
if(FD_ISSET(server_fd, &read_fds)){
client_len = sizeof(client_addr);
client_fd = accept(server_fd, (struct sockaddr *)&client_addr, &client_len);
if(client_fd == -1){
perror("accept");
continue;
}
printf("客户端 %s:%d 已连接\n", inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port));
// 将新的客户端 socket 添加到数组中
for(i = 0; i < MAX_CLIENTS; i++){
if(client_sockets[i] == 0){
client_sockets[i] = client_fd;
break;
}
}
}
// 遍历所有客户端 socket,查看是否有数据可读,如果有,就读取数据并发送回去
for(i = 0; i < MAX_CLIENTS; i++){
client_fd = client_sockets[i];
if(FD_ISSET(client_fd, &read_fds)){
memset(buffer, 0, sizeof(buffer));
if((valread = read(client_fd, buffer, sizeof(buffer))) == 0){
// 如果客户端断开了连接,就关闭 socket 并从数组中移除
getpeername(client_fd, (struct sockaddr *)&client_addr, &client_len);
printf("客户端 %s:%d 已断开连接\n", inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port));
close(client_fd);
client_sockets[i] = 0;
}
else{
// 向客户端发送收到的数据
send(client_fd, buffer, valread, 0);
}
}
}
}
close(server_fd);
return 0;
}
```
这个程序会在本机上的 8888 端口上监听,并且每次接收到一个客户端连接请求,就会向客户端发送一条欢迎信息,并且关闭连接。使用 select() 函数可以同时处理多个客户端连接,提高了服务器的并发能力。
用c语言编写程序实现两个稀疏矩阵的乘积。
好的,这是一个有趣的问题。以下是一个简单的C语言程序,可以计算两个稀疏矩阵的乘积:
```c
#include <stdio.h>
#include <stdlib.h>
typedef struct {
int row, col, value;
} Element;
typedef struct {
int row, col, num;
Element *data;
} SparseMatrix;
void createSparseMatrix(SparseMatrix *matrix) {
printf("Enter the number of rows: ");
scanf("%d", &matrix->row);
printf("Enter the number of columns: ");
scanf("%d", &matrix->col);
printf("Enter the number of non-zero elements: ");
scanf("%d", &matrix->num);
matrix->data = (Element *)malloc(matrix->num * sizeof(Element));
printf("Enter the elements in the format (row, column, value):\n");
for (int i = 0; i < matrix->num; i++) {
scanf("%d %d %d", &matrix->data[i].row, &matrix->data[i].col, &matrix->data[i].value);
}
}
void printSparseMatrix(SparseMatrix matrix) {
printf("\n");
int k = 0;
for (int i = 0; i < matrix.row; i++) {
for (int j = 0; j < matrix.col; j++) {
if (k < matrix.num && i == matrix.data[k].row && j == matrix.data[k].col) {
printf("%d ", matrix.data[k++].value);
} else {
printf("0 ");
}
}
printf("\n");
}
}
void multiplySparseMatrix(SparseMatrix matrix1, SparseMatrix matrix2, SparseMatrix *result) {
if (matrix1.col != matrix2.row) {
printf("Error: Invalid matrix dimensions\n");
return;
}
result->row = matrix1.row;
result->col = matrix2.col;
result->num = 0;
result->data = (Element *)malloc(result->row * result->col * sizeof(Element));
int *temp = (int *)calloc(matrix2.col, sizeof(int));
for (int i = 0; i < matrix1.row; i++) {
int k = 0;
for (int j = 0; j < matrix2.col; j++) {
int sum = 0;
while (k < matrix1.num && matrix1.data[k].row == i) {
int col = matrix1.data[k].col;
int val = matrix1.data[k].value;
sum += val * matrix2.data[col * matrix2.col + j].value;
k++;
}
if (sum != 0) {
result->data[result->num].row = i;
result->data[result->num].col = j;
result->data[result->num].value = sum;
result->num++;
}
}
}
}
int main() {
SparseMatrix matrix1, matrix2, result;
printf("Enter the first matrix:\n");
createSparseMatrix(&matrix1);
printf("Enter the second matrix:\n");
createSparseMatrix(&matrix2);
multiplySparseMatrix(matrix1, matrix2, &result);
printf("\nProduct of the two matrices:\n");
printSparseMatrix(result);
return 0;
}
```
这个程序定义了两个结构体:`Element` 和 `SparseMatrix`,分别表示一个元素和一个稀疏矩阵。`Element` 结构体包含了一个元素的行、列和值,`SparseMatrix` 结构体包含了一个稀疏矩阵的行、列、非零元素个数和数据。
程序中的 `createSparseMatrix` 函数用于创建一个稀疏矩阵, `printSparseMatrix` 函数用于打印一个稀疏矩阵, `multiplySparseMatrix` 函数用于计算两个稀疏矩阵的乘积。
主函数中,我们首先调用 `createSparseMatrix` 函数两次分别创建两个稀疏矩阵,然后调用 `multiplySparseMatrix` 函数计算它们的乘积,最后调用 `printSparseMatrix` 函数打印结果矩阵。
需要注意的是,这里的程序实现了稀疏矩阵的乘积,所以输入的矩阵必须是稀疏矩阵。如果要计算普通矩阵的乘积,需要用到常规的矩阵乘法算法,这里不再赘述。