2022嵌入式10-20

已于 2022-10-20 21:04:34 修改
阅读量77 收藏
点赞数
文章标签： c++ c语言 开发语言
于 2022-10-20 21:04:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_59751955/article/details/127435122
版权

这里写目录标题

驱动中断子系统

demo.c


#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/fs.h>
#include <linux/gpio.h>
#include <linux/init.h>
#include <linux/interrupt.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/of_gpio.h>
#include <linux/of_irq.h>
#include <linux/slab.h>
#include <linux/uaccess.h>

#define CNAME "mycdev_led_key"
#define COUNT 3

unsigned int number;
struct cdev* cdev;
int minor = 0;

#if 0
unsigned int major = 0;//动态申请
#else
unsigned int major = 500; //静态指定设备号
#endif

char kbuf[128] = { 0 };
struct class* cls;
struct device* dev;

//定义一个指向设备节点的指针
struct device_node* node;
struct property* pr; //属性结构体指针
int gpioled[3]; //存放gpio编号
unsigned int irqno[3] = { 0 };//存放软中断号
char* name[] = { "key1", "key2", "key3" };

int curno; //记录打开的是哪一个设备节点

//定义等待队列头
wait_queue_head_t wq;
//判断标志位
int condition;

//中断处理函数
irqreturn_t key_irq(int irq, void* dev)
{
    switch ((int)dev) {
    case 0: {
        printk("key1 down led1 invert\n");
        number=gpio_get_value(gpioled[2]);
        gpio_set_value(gpioled[2],!number);
    } break;
    case 1: {
        printk("key2 down led2 invert\n");
        number=gpio_get_value(gpioled[1]);
        gpio_set_value(gpioled[1],!number);
    } break;
    case 2: {
        printk("key3 down led3 invert\n");
        number=gpio_get_value(gpioled[0]);
        gpio_set_value(gpioled[0],!number);
    } break;
    }
    
    number=!number;
    //printk("number=%d\n",number);

    //防止唤醒后马上休眠
    condition=1;
    wake_up_interruptible(&wq);
    return IRQ_HANDLED;
}

int mycdev_open(struct inode* inode, struct file* filp)
{
    curno = MINOR(inode->i_rdev);
    printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    return 0;
}

ssize_t mycdev_read(struct file* filp,
    char __user* ubuf, size_t size, loff_t* offs)
{
    int ret;

    //判断打开的方式
    if(filp->f_flags & O_NONBLOCK)
    {
        //非阻塞
        return -EINVAL;
    }
    else
    {
        //阻塞
        ret = wait_event_interruptible(wq,condition);
        if(ret==-ERESTARTSYS)
        {
            printk("接收阻塞休眠\n");
            return ret;
        }
    }

    //printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);

    if (size > sizeof(number))
        size = sizeof(number);
    ret = copy_to_user(ubuf, &number, size);
    if (ret) {
        printk("copy data to user error\n");
        return -EINVAL;
    }

    //将conditon设置为0,为后面调用考虑
    condition=0;

    return size;
}

ssize_t mycdev_write(struct file* filp,
    const char __user* ubuf, size_t size, loff_t* offs)
{
    int ret;
    //printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    if (size > sizeof(kbuf))
        size = sizeof(kbuf);
    ret = copy_from_user(kbuf, ubuf, size);
    if (ret) {
        printk("copy data from user error\n");
        return -EINVAL;
    }

    return size;
}

int mycdev_close(struct inode* inode, struct file* filp)
{
    printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    return 0;
}

const struct file_operations fops = {
    .open = mycdev_open,
    .read = mycdev_read,
    .write = mycdev_write,
    .release = mycdev_close,
};

static int gpio_dtb_init(void)
{
    int ret, i;
    //根据设备节点路径获取设备节点信息
    node = of_find_node_by_path("/mycdev");
    if (node == NULL) {
        printk("获取节点信息失败\n");
        return ENODATA;
    }
    printk("获取节点信息成功\n");
    //获取gpio编号
    gpioled[0] = of_get_named_gpio(node, "led1", 0);
    if (gpioled[0] < 0) {
        printk("获取extend-led1编号失败\n");
        return gpioled[0];
    }
    printk("获取extend-led1编号成功\n");
    gpioled[1] = of_get_named_gpio(node, "led2", 0);
    if (gpioled[1] < 0) {
        printk("获取extend-led2编号失败\n");
        return gpioled[1];
    }
    printk("获取extend-led2编号成功\n");
    gpioled[2] = of_get_named_gpio(node, "led3", 0);
    if (gpioled[2] < 0) {
        printk("获取extend-led3编号失败\n");
        return gpioled[2];
    }
    printk("获取extend-led3编号成功\n");

    for (i = 0; i < 3; i++) {
        //申请gpio编号使用权
        ret = gpio_request(gpioled[i], NULL);
        if (ret) {
            printk("申请设备编号失败\n");
            return ret;
        }
        //设置输出方式
        gpio_direction_output(gpioled[i], 0);

    }
    return 0;
}

static int gpio_dtb_exit(void)
{
    //释放设备号
    int i;
    for (i = 0; i < 3; i++) {
        // gpio_set_value(gpioled[i], 0);
        gpio_free(gpioled[i]);
    }
    return 0;
}

static int myirq_init(void)
{
    int ret,i;
    //获取到设备树的节点
    node = of_find_compatible_node(NULL,NULL,"mycdev,woo");
    if(node ==NULL)
    {
        printk("get node error\n");
        return -ENODATA;
    }
    //解析得到软中断号
    for(i=0;i<ARRAY_SIZE(irqno);i++)
    {
        irqno[i]=irq_of_parse_and_map(node,i);
        if(irqno[i]==0)
        {
            printk("get irq number error\n");
            return -EAGAIN;
        }
        //注册中断
        ret = request_irq(irqno[i],key_irq,IRQF_TRIGGER_FALLING,name[i],(void *)i);
        if(ret)
        {
            printk("request irq error\n");
            return ret;
        }
    }
    return 0;
}

static int myirq_exit(void)
{
    int i;
    for(i=0;i<ARRAY_SIZE(irqno);i++)
    {
        free_irq(irqno[i],(void *)i);
    }
    return 0;
}

static int __init mycdev_init(void)
{
    int ret, i;
    dev_t devno;
    //分步注册
    // 1.分配对象
    cdev = cdev_alloc();
    if (cdev == NULL) {
        printk("alloc cdev memory error\n");
        ret = -ENOMEM;
        goto ERR1;
    }
    // 2.对象初始化
    cdev_init(cdev, &fops);

    // 3.设备号的申请
    if (major == 0) {
        //动态申请
        ret = alloc_chrdev_region(&devno, minor, COUNT, CNAME);
        if (ret) {
            printk("dynamic:request device number error\n");
            goto ERR2;
        }
        major = MAJOR(devno);
        minor = MINOR(devno);
    } else {
        //静态指定
        ret = register_chrdev_region(MKDEV(major, minor), COUNT, CNAME);
        if (ret) {
            printk("static:request device number error\n");
            goto ERR2;
        }
    }

    // 4.字符设备驱动的注册
    ret = cdev_add(cdev, MKDEV(major, minor), COUNT);
    if (ret) {
        printk("register chardev error\n");
        goto ERR3;
    }

    // 5.自动创建设备节点
    cls = class_create(THIS_MODULE, CNAME);
    if (IS_ERR(cls)) {
        printk("class create error\n");
        ret = PTR_ERR(cls);
        goto ERR4;
    }
    for (i = minor; i < minor + COUNT; i++) {
        dev = device_create(cls, NULL, MKDEV(major, i), NULL, "my_led%d", i);
        if (IS_ERR(dev)) {
            printk("device create error\n");
            ret = PTR_ERR(dev);
            goto ERR5;
        }
    }

    //初始化等待队列头
    init_waitqueue_head(&wq);

    //根据设备树信息进行gpio控制
    gpio_dtb_init();

    //设置中断
    myirq_init();

    return 0;

ERR5:
    for (--i; i >= minor; i--) {
        device_destroy(cls, MKDEV(major, i));
    }
    class_destroy(cls);
ERR4:
    cdev_del(cdev);
ERR3:
    unregister_chrdev_region(MKDEV(major, minor), COUNT);
ERR2:
    kfree(cdev);
ERR1:
    return ret;
}

static void __exit mycdev_exit(void)
{
    int i;

    //释放设备号
    gpio_dtb_exit();

    //释放中断
    myirq_exit();

    //注销设备节点
    for (i = minor; i < minor + 3; i++) {
        device_destroy(cls, MKDEV(major, i));
    }
    class_destroy(cls);
    //字符设备驱动的注销
    cdev_del(cdev);
    //设备号释放
    unregister_chrdev_region(MKDEV(major, minor), COUNT);
    //释放cdev的内存空间
    kfree(cdev);
}
module_init(mycdev_init);
module_exit(mycdev_exit);
MODULE_LICENSE("GPL");

test.c

#include<stdio.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<unistd.h>
#include<stdlib.h>
#include<string.h>
#include <sys/wait.h>

int main(int argc, char const *argv[])
{
    pid_t pid;
    char buf[128]="";
    int num;
    int fd=open("/dev/my_led0",O_RDWR);
    int which;
    if(fd<0)
    {
        printf("打开设备文件失败\n");
        exit(-1);
    }
    printf("设备文件打开成功\n");

    while(1)
    {
        read(fd,&num,sizeof(num));
        printf("number:%d\n",num);
        sleep(1);
    }

    close(fd);
    
    return 0;
}

platform

demo.c

#include <linux/init.h>
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/mod_devicetable.h>
#include <linux/of.h>
#include <linux/of_gpio.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/fs.h>
#include <linux/gpio.h>
#include <linux/interrupt.h>
#include <linux/of_irq.h>

/*
myplatform{
    compatible = "jyp,myplatform"; 
    interrupt-parent = <&gpiof>;
    interrupts = <9 0>,<7 0>,<8 0>;
    led1 = <&gpioe 10 0>; 
    led2 = <&gpiof 10 0>;
    led3 = <&gpioe 8 0>;
};
*/

#define CNAME "mycdev_led_key"
#define COUNT 3

struct resource *res;
struct gpio_desc *gpioled[3]; //存放gpio编号

unsigned int number;
struct cdev* cdev;
int minor = 0;

#if 0
unsigned int major = 0;//动态申请
#else
unsigned int major = 500; //静态指定设备号
#endif

char kbuf[128] = { 0 };
struct class* cls;
struct device* dev;

//定义一个指向设备节点的指针
struct device_node* node;
struct property* pr; //属性结构体指针
unsigned int irqno[3] = { 0 };//存放软中断号
char* name[] = { "key1", "key2", "key3" };

int curno; //记录打开的是哪一个设备节点

//定义等待队列头
wait_queue_head_t wq;
//判断标志位
int condition;

//给定时器分配对象
struct timer_list mytimer;

//分配工作队列对象
struct work_struct work;

//定时器处理函数
void timer_handler(struct timer_list *timer)
{
    //定时器时间到了就启动工作队列
    schedule_work(&work);
}

//底半部处理函数
void work_func(struct work_struct *work)
{
    printk("-----timer and workqueue test-----\n");
    mod_timer(&mytimer,jiffies+HZ);
}

//中断处理函数
irqreturn_t key_irq(int irq, void* dev)
{
    switch ((int)dev) {
    case 0: {
        printk("key1 down led1 invert\n");
        number=gpiod_get_value(gpioled[2]);
        gpiod_set_value(gpioled[2],!number);
    } break;
    case 1: {
        printk("key2 down led2 invert\n");
        number=gpiod_get_value(gpioled[1]);
        gpiod_set_value(gpioled[1],!number);
    } break;
    case 2: {
        printk("key3 down led3 invert\n");
        number=gpiod_get_value(gpioled[0]);
        gpiod_set_value(gpioled[0],!number);
    } break;
    }

    number=!number;
    //printk("number=%d\n",number);

    //防止唤醒后马上休眠
    condition=1;
    wake_up_interruptible(&wq);
    return IRQ_HANDLED;
}

int mycdev_open(struct inode* inode, struct file* filp)
{
    curno = MINOR(inode->i_rdev);
    printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    return 0;
}

ssize_t mycdev_read(struct file* filp,
    char __user* ubuf, size_t size, loff_t* offs)
{
    int ret;

    //判断打开的方式
    if(filp->f_flags & O_NONBLOCK)
    {
        //非阻塞
        return -EINVAL;
    }
    else
    {
        //阻塞
        ret = wait_event_interruptible(wq,condition);
        if(ret==-ERESTARTSYS)
        {
            printk("接收阻塞休眠\n");
            return ret;
        }
    }

    //printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);

    if (size > sizeof(number))
        size = sizeof(number);
    ret = copy_to_user(ubuf, &number, size);
    if (ret) {
        printk("copy data to user error\n");
        return -EINVAL;
    }

    //将conditon设置为0,为后面调用考虑
    condition=0;

    return size;
}

ssize_t mycdev_write(struct file* filp,
    const char __user* ubuf, size_t size, loff_t* offs)
{
    int ret;
    //printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    if (size > sizeof(kbuf))
        size = sizeof(kbuf);
    ret = copy_from_user(kbuf, ubuf, size);
    if (ret) {
        printk("copy data from user error\n");
        return -EINVAL;
    }

    return size;
}

int mycdev_close(struct inode* inode, struct file* filp)
{
    printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    return 0;
}

const struct file_operations fops = {
    .open = mycdev_open,
    .read = mycdev_read,
    .write = mycdev_write,
    .release = mycdev_close,
};


int gpio_irq_init(struct device_node *node)
{
    int i,ret;
    //获取并注册中断
    //解析得到软中断号
    for(i=0;i<ARRAY_SIZE(irqno);i++)
    {
        irqno[i]=irq_of_parse_and_map(node,i);
        if(irqno[i]==0)
        {
            printk("get irq number error\n");
            return -EAGAIN;
        }
        //注册中断
        ret = request_irq(irqno[i],key_irq,IRQF_TRIGGER_FALLING,name[i],(void *)i);
        if(ret)
        {
            printk("request irq error\n");
            return ret;
        }
    }

    //获取gpio编号并初始化
    gpioled[0]=gpiod_get_from_of_node(node,"led1",0,GPIOD_OUT_HIGH,NULL);
     if(IS_ERR(gpioled[0]))
     {
      printk("获取GPIO编号失败\n");
      return PTR_ERR(gpioled[0]);
     }
    printk("获取extend-led1编号成功\n");
    gpioled[1]=gpiod_get_from_of_node(node,"led2",0,GPIOD_OUT_HIGH,NULL);
     if(IS_ERR(gpioled[1]))
     {
      printk("获取GPIO编号失败\n");
      return PTR_ERR(gpioled[1]);
     }
    printk("获取extend-led2编号成功\n");
    gpioled[2]=gpiod_get_from_of_node(node,"led3",0,GPIOD_OUT_HIGH,NULL);
     if(IS_ERR(gpioled[2]))
     {
      printk("获取GPIO编号失败\n");
      return PTR_ERR(gpioled[2]);
     }
    printk("获取extend-led3编号成功\n");
    return 0;
}

void gpio_irq_exit(void)
{
    int i;
    //释放中断
    for(i=0;i<ARRAY_SIZE(irqno);i++)
    {
        free_irq(irqno[i],(void *)i);
    }

     //释放设备号
    for (i = 0; i < 3; i++) {
        // gpio_set_value(gpioled[i], 0);
        gpiod_put(gpioled[i]);
    }

}

int pdrv_probe(struct platform_device *pdr)
{
    int ret, i;
    dev_t devno;

    //获取gpio编号和中断号
    ret=gpio_irq_init(pdr->dev.of_node);
    if(ret!=0)
    {
        printk("初始化led和irq失败\n");
        return ret;
    }

    //工作队列对象初始化
    INIT_WORK(&work,work_func);

    //分步注册
    // 1.分配对象
    cdev = cdev_alloc();
    if (cdev == NULL) {
        printk("alloc cdev memory error\n");
        ret = -ENOMEM;
        goto ERR1;
    }
    // 2.对象初始化
    cdev_init(cdev, &fops);

    // 3.设备号的申请
    if (major == 0) {
        //动态申请
        ret = alloc_chrdev_region(&devno, minor, COUNT, CNAME);
        if (ret) {
            printk("dynamic:request device number error\n");
            goto ERR2;
        }
        major = MAJOR(devno);
        minor = MINOR(devno);
    } else {
        //静态指定
        ret = register_chrdev_region(MKDEV(major, minor), COUNT, CNAME);
        if (ret) {
            printk("static:request device number error\n");
            goto ERR2;
        }
    }

    // 4.字符设备驱动的注册
    ret = cdev_add(cdev, MKDEV(major, minor), COUNT);
    if (ret) {
        printk("register chardev error\n");
        goto ERR3;
    }

    // 5.自动创建设备节点
    cls = class_create(THIS_MODULE, CNAME);
    if (IS_ERR(cls)) {
        printk("class create error\n");
        ret = PTR_ERR(cls);
        goto ERR4;
    }
    for (i = minor; i < minor + COUNT; i++) {
        dev = device_create(cls, NULL, MKDEV(major, i), NULL, "my_led%d", i);
        if (IS_ERR(dev)) {
            printk("device create error\n");
            ret = PTR_ERR(dev);
            goto ERR5;
        }
    }

    //初始化等待队列头
    init_waitqueue_head(&wq);

    //初始化定时器对象
    mytimer.expires=jiffies+HZ;//定时1s
    timer_setup(&mytimer,timer_handler,0);
    //注册定时器
    add_timer(&mytimer);

    return 0;

ERR5:
    for (--i; i >= minor; i--) {
        device_destroy(cls, MKDEV(major, i));
    }
    class_destroy(cls);
ERR4:
    cdev_del(cdev);
ERR3:
    unregister_chrdev_region(MKDEV(major, minor), COUNT);
ERR2:
    kfree(cdev);
ERR1:
    return ret;
}

int pdrv_remove(struct platform_device *pdr)
{
    int i;
    printk("%s:%d\n",__FILE__,__LINE__);

    //取消工作队列的执行
    cancel_work_sync(&work);

    //删除定时器对象
    del_timer(&mytimer);

    //释放设备号与中断
    gpio_irq_exit();

    //注销设备节点
    for (i = minor; i < minor + 3; i++) {
        device_destroy(cls, MKDEV(major, i));
    }
    class_destroy(cls);
    //字符设备驱动的注销
    cdev_del(cdev);
    //设备号释放
    unregister_chrdev_region(MKDEV(major, minor), COUNT);
    //释放cdev的内存空间
    kfree(cdev);
    return 0;
}

//定义compatible表
struct of_device_id oftable[]={
    {.compatible="jyp,myplatform"},
    {},
};
MODULE_DEVICE_TABLE(jyp,oftable);//安装设备时，自动安装驱动

//定义并初始化对象
struct platform_driver pdrv = {
    .probe=pdrv_probe,
    .remove=pdrv_remove,
    .driver={
        .name = "test",
        .of_match_table=oftable,//设备树匹配
    },
};

module_platform_driver(pdrv); //一键注册宏
MODULE_LICENSE("GPL");//许可证
MODULE_AUTHOR("jyp");//作者信息

test.c

#include<stdio.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<unistd.h>
#include<stdlib.h>

int main(int argc, char const *argv[])
{
    int num;
    int fd=open("/dev/my_led0",O_RDWR);
    int which;
    if(fd<0)
    {
        printf("打开设备文件失败\n");
        exit(-1);
    }
    printf("设备文件打开成功\n");

    while(1)
    {
        read(fd,&num,sizeof(num));
        printf("number:%d\n",num);
    }

    close(fd);
    return 0;
}
xiaoin*
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
2022年ATmega-单片机的模拟接口及使用方法.ppt
11-02
2022年的ATmega单片机仍然保持着其在电子设计中的重要地位，其模拟接口是实现与外界模拟信号交互的关键部分。本章主要讨论了ATmega单片机的模拟接口，包括模拟比较器和模数转换器（A/D转换器）的原理、使用方法以及...
ARM嵌入式开发-Linux内核篇视频教程
06-07
20 - LED设备驱动4.mp4 3.5M2017-08-16 22:47  02 - 开篇的话2.mp4 13.3M2017-08-16 22:47  21 - LED设备驱动5.avi 21.5M2017-08-16 22:47  36 - 声卡驱动1.mp4 15.3M2017-08-16 22:47  47 - LCD驱动6.avi ...
嵌入式试卷-选择题终版.pdf
03-06
20. 预取中止异常：如果预取的指令地址不存在或不允许访问，将触发指令预取中止异常。 21. 系统功能调用：通过软件中断（SWI）异常机制可以实现系统功能调用。 22. 系统复位模式：系统复位后，处理器进入管理模式...
嵌入式Linux-期末考试题含答案.pdf
02-11
【嵌入式Linux期末考试题解析】 1. 关于Linux安装的说法中，错误的选项是C。当选择“自动分区”时，系统通常不会保存硬盘上原有的数据，而是会重新分区，因此C选项不正确。 2. 错误的选项是A。Shell程序编写完成后...
倍福选型beckhoff-products-2022-2023.pdf
10-28
Beckhoff 提供多种类型的工业PC，如嵌入式PC、面板PC、机架式PC和盒式PC等，适用于不同规模和复杂性的项目。这些PC均基于开放式标准，可与各种软PLC、控制软件和硬件组件无缝集成，确保灵活性和可扩展性。 **Twin...
C++之模板（四）
CSDN_HZW的博客
06-18 260
【代码】C++之模板（四）
C++ day3
2301_81402136的博客
06-17 284
【代码】C++ day3。
【C++】类的六个默认成员函数
炸掉地球的博客
06-21 661
C++类的六个默认构造函数。
什么悬挂指针，如何避免（C/C++）
qq_35374791的博客
06-24 261
RAII 是 C++ 中一种重要的资源管理技术，它将资源的获取与对象的构造绑定在一起，并在对象销毁时自动释放资源。悬挂指针是指向已经被释放或者不再存在的内存区域的指针。当程序尝试使用这样的指针访问或修改已释放的内存时，会导致未定义行为，通常是程序崩溃或数据损坏。或使用智能指针来实现。在现代 C++ 编程中，推荐尽可能使用智能指针来管理动态分配的资源。总之，预防悬挂指针的关键在于确保指针在使用前不会指向无效的内存，这可以通过立即设置为。会在离开作用域时自动释放它所管理的内存，从而避免了悬挂指针的问题。
【C++】二叉搜索树|Key模型|key_value模型|基本操作
m0_67367079的博客
06-24 516
BST。每个节点包含一个键（key）和两个指针，分别指向其左子树和右子树。左子树上的所有节点的键值都小于其父节点的键值。右子树上的所有节点的键值都大于其父节点的键值。每个子树也是一棵二叉搜索树。每个节点包含三个部分：一个键（Key），一个值（Value），以及两个指向其子节点的指针（分别指向左子树和右子树）。
C++之模板（三）
CSDN_HZW的博客
06-18 333
可以将数据结构类型传递进来，比如=vectop<T>（如果没传就是默认）Stack.hmain.cpp。
C++ constexpr, consteval, 和 constinit简要介绍
arong_xu的博客
06-22 804
C++ constexpr, consteval, constinit简介
C++ 修饰符类型：深入理解与应用
男Ren、麦根的博客
06-18 472
在 C++ 编程中，修饰符（Modifiers）是编程语言中一种重要的语法特性，用于改变变量、函数、类等的默认行为或属性。修饰符在 C++ 中扮演着至关重要的角色，它们不仅有助于增强代码的可读性和可维护性，还提供了更灵活和强大的编程能力。本文将深入探讨 C++ 中的修饰符类型，包括存储类修饰符、访问修饰符和函数修饰符，并分享其应用与最佳实践。
322. 零钱兑换-c语言
最新发布
weixin_43327597的博客
06-24 74
计算并返回可以凑成总金额所需的 最少的硬币个数。如果没有任何一种硬币组合能组成总金额，返回 -1。给你一个整数数组 coins ，表示不同面额的硬币；以及一个整数 amount ，表示总金额。输入：coins = [1, 2, 5], amount = 11。输入：coins = [2], amount = 3。输入：coins = [1], amount = 0。你可以认为每种硬币的数量是无限的。解释：11 = 5 + 5 + 1。
【C++课设】超市商品管理系统设计（结构体完成）
祖国花朵的博文
06-18 353
课设作品
什么野指针（c++）
qq_35374791的博客
06-24 976
野指针（Wild Pointer）是指向不确定位置或者非法地址的指针。当一个指针指向的内存被释放后，如果没有将其设置为NULL，那么这个指针就变成了野指针。使用野指针会导致未定义行为，可能引发程序崩溃或数据损坏。
makefile文件编写（C）
baidu_34971492的博客
06-24 94
这个Makefile定义了如何编译和链接你的程序。CC变量指定了编译器（这里是gcc），CFLAGS变量包含了编译器的标志，比如警告选项和调试信息，LDFLAGS变量用于链接时的选项。运行Makefile：在命令行中运行make命令，Makefile会根据其规则自动编译和链接你的程序。
【华为OD机试】 硬件产品销售方案（C++/Java/Python）
dvlinker的技术专栏
06-24 9
【华为OD机试】 硬件产品销售方案（C++/Java/Python）
C++性能分析工具gperftools安装教程与使用案例分析
FRIGIDWINTER的博客
06-17 833
gperftools是由谷歌开发的一套性能分析工具。它主要用于帮助开发人员更好地了解其程序的性能瓶颈并进行有效的优化。本文介绍gperftools的安装流程，并给出实际案例加深理解
中值滤波算法--C 语言嵌入式
07-10
{10, 20, 30, 40, 50}, {60, 70, 80, 90, 100}, {110, 120, 130, 140, 150}, {160, 170, 180, 190, 200}, {210, 220, 230, 240, 250} }; // 打印原始图像 printf("Original Image:\n"); for (int i = 0; i...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值