精华内容
下载资源
问答
  • 轻量级的面向对象C语言编程框架.pdf
  • 轻量级的面向对象C语言编程框架介绍,非常不错的宏定义,对C有很大的提高
  • OOC 面向对象C语言编程实践

    千次阅读 2016-07-23 17:10:57
    面向对象是一种编程思想,虽然C并没有提供面向对象的语法糖,但仍然可以用面向对象的思维来抽象和使用。这里分享一套C面向对象的写法,可以完成面向对象编程并进行流畅的抽象。这套写法是在实践中不断调整的结果,...

        面向对象是一种编程思想,虽然C并没有提供面向对象的语法糖,但仍然可以用面向对象的思维来抽象和使用。这里分享一套C面向对象的写法,可以完成面向对象编程并进行流畅的抽象。这套写法是在实践中不断调整的结果,目前已经比较稳定,进行了大量的功能编写。


         这套OOC有以下特性:

    • 没有强行去模仿c++的语法设定,而是使用C的特性去面向对象设计
    • 实现继承,组合,封装,多态的特性
    • 一套命名规范去增加代码的可读性

          第一,封装
          在C中可以用struct来封装数据,如果是方法,我们就需要用函数指针存放到struct里面来模拟。
    typedef struct Drawable Drawable;
    struct  Drawable
    {
    	 float positionX;
    	 float positionY;
    };
    typedef struct {
    	Drawable* (*Create)                ();
    	void      (*Init)                  (Drawable* outDrawable);
    }
    _ADrawable_;
    
    extern _ADrawable_ ADrawable[1];
    static void InitDrawable(Drawable* drawable)
    {
         drawable->positionX = 0.0f;
         drawable->positionY = 0.0f;
    }
    
    static Drawable* Create()
    {
    	Drawable* drawable = (Drawable*) malloc(sizeof(Drawable));
    	InitDrawable(drawable);
    
    	return drawable;
    }
    
    static void Init(Drawable* outDrawable)
    {
    	InitDrawable(outDrawable);
    }
    
    _ADrawable_ ADrawable[1] =
    {
    	Create,
    	Init,
    };
    • 数据我们封装在Drawable结构里,通过Create可以再堆上创建需要自己free,Init是在栈上创建
    • 函数封装在ADrawable这个全局单例对象里,由于没有this指针,所有方法第一个参数需要传入操作对象
    • Create和Init方法将会管理,对象的数据初始化工作。如果对象含有其它对象,就需要调用其Create或Init方法

        第二,继承和组合
    typedef struct Drawable Drawable;
    struct  Drawable
    {
    	 Drawable* parent;
    	 Color     color[1];
    };
    • 继承,就是在结构体里,嵌入另一个结构体。这样malloc一次就得到全部的内存空间,释放也就一次。嵌入的结构体就是父类,子类拥有父类全部的数据空间内容。
    • 组合,就是在结构体,存放另一个结构体的指针。这样创建结构体时候,要需要调用父类的Create方法去生成父类空间,释放的时候也需要额外释放父类空间。
    • 这里parent就是组合,color就是继承。
    • 继承是一种强耦合,无论如何子类拥有父类全部的信息。
    • 组合是一种低耦合,如果不初始化,子类只是存放了一个空指针来占位关联。
    • 可以看到,C里面一个结构体可以,继承任意多个父类,也可以组合任意多个父类。
    • color[1] 使用数组形式,可以直接把color当做指针使用
            子类访问父类,可以直接通过成员属性。那么如果通过父类访问子类呢 ?  通过一个宏定义来实现这个功能。
    /**
     * Get struct pointer from member pointer
     */
    #define StructFrom2(memberPtr, structType) \
    	((structType*) ((char*) memberPtr - offsetof(structType, memberPtr)))
    
    
    /**
     * Get struct pointer from member pointer
     */
    #define StructFrom3(memberPtr, structType, memberName) \
    	((structType*) ((char*) memberPtr - offsetof(structType, memberName)))
    
    
    typedef struct Sprite Sprite;
    struct  Sprite
    {
    	Drawable drawable[1];
    };
    Sprite* sprite = StructFrom2(drawable, Sprite);

         这样,我们就可以,通过Sprite的父类Drawable属性,来获得子类Sprite的指针。其原理,是通过offsetof获得成员偏移量,然后用成员地址偏移到子类地址上。有了这个机制,我们就可以实现多态,接口等抽象层。

         我们可以在接口函数中,统一传入父类对象,就可以拿到具体的子类指针,执行不同的逻辑,让接口方法体现出多态特性。


          第三, 多态
    typedef struct Drawable Drawable;
    struct  Drawable
    {
    	 /** Default 0.0f */
    	 float     width;
    	 float     height;
    
    	 /**
    	  * Custom draw called by ADrawable's Draw, not use any openGL command
    	  */
    	 void (*Draw)  (Drawable* drawable);
    };
        当,我们把一个函数指针放入,结构体对象的时候。意味着,在不同的对象里,Draw函数可以替换为不同的实现。而不是像在ADrawable里面的函数只有一个固定的实现。在子类继承Drawable的时候,我们可以给Draw赋予具体的实现。而统一的调用Draw(Drawable* drawable)的时候,就会体现出多态特性,不同的子类有不懂的实现。
    typedef struct
    {
        Drawable drawable[1];
    }
    Hero;
    typedef struct
    {
        Drawable drawable[1];
    }
    Enemy;
    Drawable drawables[] = 
    {
         hero->drawable,
         enemy->drawable,
    };
    
    for (int i = 0; i < 2; i++)
    {
        Drawable* drawable = drawables[i];
        drawable->Draw(drawable);
    }

         在Hero和Enemy的Create函数中,我们分别实现Draw(Drawable* drawable)函数。如果,我们有一个绘制队列,里面都是Drawable对象。传入Hero和Enemy的Drawable成员属性。在统一绘制调用中,drawable->Draw(drawable),就会分别调用Hero和Enemy不同的draw函数实现,体现了多态性。

       

        第四,重写父类方法

        在继承链中,我们常常需要重写父类方法,有时候还需要调用父类方法。
    typedef struct
    {
        Sprite sprite[1];
    }
    SpriteBatch;
         比如,SpriteBatch 继承 Sprite, 我们需要重写Draw方法,还需要调用Sprite的Draw方法。那么我们就需要把Sprite的Draw方法公布出来。
    typedef struct
    {
       Drawable drawable[1];
    }
    Sprite;
    
    typedef struct
    {
        void (*Draw)(Drawable* drawable);
    }
    _ASprite_;
    
    extern _ASprite_ ASprite;
          这样,每个Sprite的Draw方法可以,通过ASprite的Draw访问。
    // override
    static void SpriteBatchDraw(Drawable* drawable)
    {
          // call father
          ASprite->Draw(drawable);
    }
    
    spriteBatch->sprite->drawable->Draw = SpriteBatchDraw;
         那么,SpriteBatch就重写了父类的Draw方法,也能够调用父类的方法了。


        第五,内存管理
        一个malloc对应一个free,所以Create出来的对象需要自己手动free。关键是,在于组合的情况。就是对象内有别的对象的指针,有些是自己malloc的,有些是共用的。其实,计数器是一个简单的方案,但我仍然觉得复杂了。在想到更好的方案之前,我倾向于更原始的手动方法,给有需要内存管理的对象添加Release方法。

    typedef struct
    {
        Drawable* parent;
        Array*    children;
    }
    Drawable;
    
    typedef struct
    {
        void (*Release)(Drawable* drawable);
    }
    _ADrawable_;
    
    extern _ADrawable_ ADrawable;

        Drawable 含有两个指针, 一个是parent可能别的对象也会使用,所以这个parent在Release函数中不能确定释放。还有一个children这个数组本身是可以释放的,所以在Create函数里,我们自己malloc的,都要在Release方法里自己free。

         所以,对于Create方法我们需要free + Release。对于Init 只需要调用Release方法就可以释放完全了。那么,parent这种公用的指针,就需要paren对象自己在合适的时机去释放自己。肯定没有计数器来的方便,但是这个足够简单开销也很小。
         
    展开全文
  • 面向对象C语言(Objective-C)编程简介

    千次阅读 2010-02-02 15:28:00
    面向对象C语言编程简介:    面向对象的C语言是一种简单的计算机语言,设计的目的是为了进行高级的面向对象编程。面向对象的C语言被定义成对标准C语言的小而强大的扩展集合。是对C语言的扩展但是主要基于...

    Introduction to The Objective-C Programming Language

    面向对象C语言编程简介:

     

        面向对象的C语言是一种简单的计算机语言,设计的目的是为了进行高级的面向对象编程。面向对象的C语言被定义成对标准C语言的小而强大的扩展集合。是对C语言的扩展但是主要基于Smalltalk语言,最早的面向对象编程语言之一。设计面向对象的C语言是为了给C语言完全的面向对象编程能力,通过一种简单直接的方法。

     

        大部分面向对象开发环境由若干部分组成:

    • 一种面向对象的编程语言

    • 一个对象库

    • 一套开发工具

    • 一个运行环境

        这篇文章是关于开发环境的第一个部分—编程语言,完全地描述了面向对象C语言,并且提供了学习第二个部分的基础,Mac OS X 的面向对象C语言应用框架—统称为 Cocoa. 你可以开始学习更多有关Cocoa 通过文章Getting Started with Cocoa. 你可以用的两种主要的开发工具是 Xcode 和 Interface Builder, 可从该网页获得描述Xcode Workspace GuideInterface Builder 单独的. 运行时环境在另外单独的文档里描述: Objective-C Runtime Programming Guide.

     

        注意: 该文档描述的Objective-C的版本是发布在苹果电脑 Mac OS X v10.6 上的, 引入了新特性:associative references (see“Associative References”). 想学习Objective-C的1.0版本(在苹果电脑 Mac OS X v10.4 或者更早的版本上可用), 请阅读: Object Oriented Programming and the Objective-C Programming Language 1.0.

     

    谁应该阅读该文档

     

        该文档是为有可能对以下内容有兴趣的读者准备的:

    • 使用 Objective-C 编程

    • 想了解 Cocoa 应用框架的基础原理相关的内容

        该文档即介绍了实现 Objective-C语言的面向对象模型,同事也完整的介绍了该语言。重点在于Objective-C对C语言的扩展部分,而不是C语言本事。

     

        由于这不是一篇介绍C语言的文档,它假定我们之前了解C语言。但是,也不需要深入的了解。基于Objective-C的面向对象编程和之前基于标准C语言的编程有很大的不同,因此你不会有太大的障碍即使你不是一个有经验的C程序员。

    该文档的结构

    本文档分为若干章节和一个附录。

    下面的章节涵盖了所有Objective - C对标准C语言扩展的功能。

    苹果的编译器基于GNU的编译器系列。Objective-C 的语法是 GNU C/C++ 语法的超集,并且Objective-C 的编译器适用于C, C++ 和Objective-C 的源代码. 编译器识别 Objective-C 的代码文件是通过文件扩展名.m, 就像它识别仅包含标准C语法的文件是通过文件扩展名.c, 同样的, 编译器识别使用Objective-C语言的C++文件是通过文件扩展名 .mm, 其它的在Objective-C 里使用 C++ 的疑问涵盖在如下文档里:“Using C++ With Objective-C.”


    附录里包含的参考资料或许对理解该语言有很大的帮助:

    约定

       当本文档导论函数,方法和其他编程元素的时候, 使用了特殊的计算机语言和斜体字。计算机语言表示单词或者字符直接字面的拿来用(写成和他们一样的--就是C语言中的关键词了). 斜体表示能表现为其他东西或者是变化的(比如变量名等)。

    比如, 语法:

    @interfaceClassName(CategoryName)

    表示 @interface 和一对圆括号是必须的, 但是你可以选择类名和分类名。

    当显示示范代码的时候,省略号表示的部分,通常是内容填充部分,已经省略了:

    - (void)encodeWithCoder:(NSCoder *)coder
    
    {
       [super encodeWithCoder:coder];
    
       ...
    }

    涉及到的附录里的约定在附录本身描述了。

     

    另请参阅

    如果你从来没有用过面向对象编程来创建过应用程序,你应该阅读:Object-Oriented Programming with Objective-C. 你应该也要考阅读下它如果你用过其他的面向对象开发环境比如说:C++,JAVA,因为它们和Objective-C有很多不同的例外情况和约定。Object-Oriented Programming with Objective-C的设计师为了帮助你熟悉面向对象的开发,向一个 Objective-C的开发者方向发展。它阐述了一些面向对象设计的实现,给你一些提示真正的编写面向对象的程序是啥样的。

     

     

    运行环境(运行时)

    Objective-C Runtime Programming Guide 描述了Objective-C 运行时的一些情况和你如何去使用它。

    Objective-C Runtime Reference描述了Objective-C 运行时支持库的数据结构和函数。你的程序可以使用这些接口来和Objective-C的运行时系统交互。比如:你可以添加一个类或者方法,或者获得一个所有已加载得的类定义的列表。Objective-C Release Notes 描述了在最新版本的 Mac OS X的一些Objective-C运行环境的变化。

     

    内存管理

    Objective-C 支持两种内存管理的环境,垃圾自动回收和引用计数:

    • Garbage Collection Programming Guide 描述了 Cocoa使用的垃圾回收机制。(iPhone上不支持—所以你无法通过iPhone的开发中心访问此文档.)

    • Memory Management Programming Guide for Cocoa 描述了Cocoa使用的引用计数系统。


    注:本文章是直接翻译的苹果官方网页上的的资料,不会随着网页的变化而及时变化,最新官方网页请参考

    https://developer.apple.com/library/ios/#documentation/Cocoa/Conceptual/ObjectiveC/Introduction/introObjectiveC.html

    欢迎朋友们指导修改~~~~

     

     

    转载请保留以下信息:
    作者(Author):smilelance
    时间( Time ):2010.02
    出处( From ):http://blog.csdn.net/smilelance

     

     

     

     

     

    展开全文
  • 面向对象编程(OOP)并不是一种特定的语言或者工具,它只是一种设计方法、设计思想。它表现出来的三个最基本的特性就是封装、继承与多态。很多面向对象的编程语言已经包含这三个特性了...其实C语言编程者应该都已经接触
  • C语言面向对象编程

    2018-06-01 16:47:30
    C语言面向对象编程技术,是C语言开发者不可多得的技术书籍
  • 附件是在VS2012下用C语言实现面向对象的示例代码,并实现设计模式中的工厂模式
  • 很多人认为,C语言编程,就是函数式编程,C++, JAVA等高级语言,才是面向对象编程。 其实,这是错误的认识!面向对象编程是一种思想,是一种编程思路,实现这种编程思路,不局限于是使用C语言还是使用C++语言。 ...

           结构体是一个非常重要的知识点,必须掌握和深入理解使用。现在网络上还经常讨论函数式编程和面向对象编程。很多人认为,C语言编程,就是函数式编程,C++, JAVA等高级语言,才是面向对象编程。

           其实,这是错误的认识!面向对象编程是一种思想,是一种编程思路,实现这种编程思路,不局限于是使用C语言还是使用C++语言。

           使用C语言也可以实现面向对象编程。例如linux的内核,这么复杂的一个操作系统,是使用C语言来设计完成,很多地方是使用了面向对象的编程思想。

           那么,使用C语言来实现“面向对象编程”思路,就是使用结构体来完成。C++中使用类来定义成员变量和方法,相应的,C语言也可以使用结构体来完成这项操作。C语言的结构体可以定义成员变量,同时,可以定义函数指针,实现C++类的方法。

           下面我通过程序测试例子来讲解“使用结构体实现面向对象编程”的知识。首先,给出程序测试例子代码:

           程序运行结果如下:

           在这个例子中,讲解一个图书管理系统中的借书和还书功能。对于读者来说,有普通读者和VIP读者。读者有借书和还书的操作。

           此时,我们使用面向对象编程的思想来设计程序。首先,分析设计程序要实现什么功能,它有什么对象进行活动,对象之间是什么关系,对象有什么操作。那么,我们可以归纳如下:

    (1) 程序是一个图书馆的借书和还书功能模块;

    (2) 程序是涉及到的活动对象是读者和图书;

    (3) 对象之间的活动关系是:读者结束、读者还书;

    (4) 读者有普通用户和VIP用户类型的区别;

    (5) 普通用户和VIP用户的借书和还书有普通的操作;

           所以,归纳出了这些问题,我们就可以有如下是设计思路:

    (1) 需要定义读者和图书这样的两个结构体类型;所以,我们定义了struct reader, struct book这样的结构体类型;

    (2) 读者结构体类型中,需要定义普通用户和VIP用户的区分属性;所以,在struct reader结构体类型中,定义了 is_vip属性,用于定义当前读者的身份类型;

    (3) 普通读者和VIP读者的借书和还书操作不一样,所以,定义普通读者操作是:

    void my_borrow_book(struct reader* preader, struct book* pbook)

    void my_payback_book(struct reader* preader, struct book* pbook)

    VIP读者的操作是:

    void my_vip_borrow_book(struct reader* preader, struct book* pbook)

    void my_vip_payback_book(struct reader* preader, struct book* pbook)

           这些函数操作是读者的一个属性,所以,需要给读者定义函数指针成员,指向具体的操作函数。如下:

    //定义函数指针, pfunc_borrow_book 类型的函数;

    pfunc_borrow_book borrow_book;

    //定义函数指针, pfunc_payback_book 类型的函数;

    pfunc_payback_book payback_book;

           最终,在init_reader_function()函数中,根据读者是否为VIP类型,给对象的函数指针成员指向不同的函数。如下:

        if(preader->is_vip)

        {

           //给函数指针赋值, 让它指向具体的函数;

           preader->borrow_book = my_vip_borrow_book;

           preader->payback_book = my_vip_payback_book;

        }

        else

        {

           preader->borrow_book = my_borrow_book;

           preader->payback_book = my_payback_book;

        }

           那么,不同的读者类型,调用相同的函数指针,就调用指向不同的函数。例如:

    r1.borrow_book(&r1, &b1);   //读者 r1 借书

    r2.borrow_book(&r2, &b2);   //读者 r2 借书

           此时,读者都是调用borrow_book函数指针指向的函数,那么,由于r1是普通用户,它的函数指针指向my_borrow_book()函数,所以,r1.borrow_book()调用的就是my_borrow_book()函数。

           同理,r2是VIP用户,它的borrow_book函数指针指向my_vip_borrow_book ()函数,所以,r2.borrow_book()调用的就是my_vip_borrow_book ()函数。

           通过这个例子,我们更深入地学习了结构体的应用,并提出了面向对象的编程思想。使用C语言的结构体知识可以实现面向对象编程。

    更多的交流可以访问:www.mylinux.vip   加QQ:1523520001,微信:13926572996,备注:linux编程;
    学习、分享更多的linux C/C++ 编程知识。
     

     

    展开全文
  • 此实例文件是文章《学会C语言面向对象编程,弄清面向对象实质。》的附件https://blog.csdn.net/weixin_42523774/article/details/105649779,是为了告诉大家如何用C语言实现面向对象的语言。
  • 闲来无事,写一下C语言如何面向对象编程吧: 面向对象编程 /*=========================================================== 文件名: class.c 版本:1.0 时间:2017-11-12 作者:连志安 功能:C语言是一个面向...

    闲来无事,写一下C语言如何面向对象编程吧:

    面向对象编程
    /*===========================================================
    
    文件名: class.c
    版本:1.0 
    时间:2017-11-12
    作者:连志安
    功能:C语言是一个面向过程编程的语言,本程序简单的实现面向对象
    		的思想,功能较为简陋。 
    
    
    1、如何定义一个类。
    其实可以使用C语言的结构体加函数指针来实现。
    例如:
    
    struct fat {
    	int age;
    	void (*create)(struct fat * this);      //创建函数
    	void (*destroy)(struct fat * this);     //销毁函数
    
        
    	void (*write)(struct fat * this);       //成员函数
    };
    typedef struct fat * class_fat;         //这一句是必须的,把结构体指针
    
    
    2、继承:
    struct son {
    	CLASS_FATHER(fat);    //继承此父类=========  这里就是继承了
        
    	void (*create)(struct son * this);  //创建函数
    	void (*destroy)(struct son * this); //销毁函数
    
        
    	void (*write)(struct son * this);   //成员函数
    };  
    typedef struct son * class_son;
    
    
    3、使用
    	struct son * son1 = new_class(son1, son);   //创建一个实例
    	
    	son1->write(son1);        //调用写函数
    	
    	del_class(son1);    //销毁实例
    
    
    4、父类函数复写:
         class_overwrite(write, son_write);	//重写父函数 write. 并用新的son_write函数
    	//class_def(write);	//不重写父函数 
    
    
    剩下的看下面代码,不懂联系 连志安
    
    ===========================================================*/
    
    #include <stdio.h>
    
    
    /*====================================================================
            以下是相关宏
    ====================================================================*/
    #define class_size(cls)	sizeof(struct cls)
    
    #define CLASS_FATHER(x)		 struct x * my_father
    #define new_class(new, cls) (struct cls *)malloc(class_size(cls)); new->create = cls##_create; new->destroy = cls##_destroy; new->create(new)
    #define del_class(new)          new->destroy(new); free(new); new = NULL
    #define father		                this->my_father
    #define CLASS_FATHER_INIT(cls)	 father = new_class(father, cls);	
    #define CLASS_FATHER_DESTROY()	del_class(father)
    
    #define class_def(x)		this->x = father->x
    #define class_overwrite(x, fun) 	this->x = fun
    
    
    
    /*===================================================
            父类
    ===================================================*/
    
    struct fat {
    	int age;
    	void (*create)(struct fat * this);      //创建函数
    	void (*destroy)(struct fat * this);     //销毁函数
    
        
    	void (*write)(struct fat * this);       //成员函数
    };
    typedef struct fat * class_fat;
    
    //父类写函数
    void fat_write(class_fat this)
    {
    	printf("fat_write \r\n");
    }
    
    //
    void fat_create(class_fat this)
    {
    	this->write = fat_write;
    	printf("fat_create \r\n");
    }
    
    void fat_destroy(class_fat this)
    {
    	printf("fat_destroy \r\n");
    }
    
    
    
    /*===================================================
            子类
    ===================================================*/
    struct son {
    	CLASS_FATHER(fat);    //继承此父类
        
    	void (*create)(struct son * this);  //创建函数
    	void (*destroy)(struct son * this); //销毁函数
    
        
    	void (*write)(struct son * this);   //成员函数
    };  
    typedef struct son * clas_son;
    
    void son_write(clas_son this)
    {
    	father->write(father);  //调用父类的写函数
    	printf("son_write \r\n");
    }
    
    
    void son_create(clas_son this)
    {
    	CLASS_FATHER_INIT(fat);//声明父类
    	
    	class_overwrite(write, son_write);	//重写父函数 
    	//class_def(write);	//不重写父函数 
    	printf("son_create \r\n");
    }
    
    void son_destroy(clas_son this)
    {
    	CLASS_FATHER_DESTROY(); //注销父类
        
    	printf("son_destroy \r\n");
    }
    
    
    
    
    
    void plubic_write(clas_son son)
    {
    	son->write(son);
    }
    
    
    int main(void)
    {
    	struct son * son1 = new_class(son1, son);   //创建一个实例
    	
    	son1->write(son1);        //调用写函数
    	
    	del_class(son1);    //销毁实例
    	
    	while(1);
    	return 0;
    }
    
    

     

    展开全文
  • C语言面向对象编程与设计模式
  • C语言C语言实现面向对象编程之封装代码.,完整的代码,可以在Linux和VS环境运行。【C语言C语言实现面向对象编程之封装代码.rar
  • C语言 面向对象编程

    2019-05-14 14:07:52
    C语言是典型的“面向过程式语言”,与之相对应的C++是“面向对象编程语言”。但是很多人不知道的是C语言也可以实现面向对象编程。从根本上说任何图灵完备的语言都可以互相实现。这么说你想用汇编实现面向对象...
  • C语言中还可以实现更深入的面向对象编程多态特性。例如:使用接口(interface)包含多个指向函数的指针,这样就可以实现操作的"多态性"。 在面向对象语言C++的实现上,使用了虚函数的方式,虚函数实质上也是指向虚表...
  • C语言使用结构体实现面向对象编程
  • 在基于对象编程实现封装的基础之上,我们接下来实现面向对象编程中的继承部分功能。这种继承特性知识实现部分面向对象编程中继承功能。本博客中我们介绍两种方式的实现继承。第一种是利用数据结构的包含实现继承功能...
  • 对于编程而言,重要的是解决问题的方式,而不是语言本身。面向对象与面向过程是解决问题和思考问题的方式。C语言常说是面向过程开发的语言,因为其缺少很多...但,这并不影响我们采用面向对象的方式,使用C语言编程
  • 一、类的封装实现:借用高焕堂的宏头文件,类很容易封装为如下的格式  1、类的定义,其中 CLASS() 是 lw_oopc_kc.h 中定义的宏 #include "lw_oopc_kc.h" CLASS(A) { int a; void(*init)(void*,int);...
  • C语言写的面向对象框架的内核部分,由于刚刚开始写,内容仅包含底层核心。本来不想要币的,但发现自己居然没币了,所以,大家支持下哈。。 ^_^
  • C语言编程新视角,编程老手的经验之谈,不同于普通的C语言编程书籍,讲解C语言编程碰到的难题,如unicode文本处理,高阶数据结构,面向对象C语言编程,Glib,POSIX库函数编程等。优质图书,值得珍藏。阅读英文原版图书,使你...
  • C语言的OOP编程 在网络上搜索C语言与C++语言的区别,有很多资料都会提到:C语言是“面向过程编程”的语言。...其实,C语言可以进行面向对象编程。例如Linux操作系统就是使用C来编写的,Linux内核...
  • 面向对象C语言(Objective-C)编程(二)

    千次阅读 2010-02-10 14:24:00
     面向对象C语言推迟了尽可能多的决策从编译和链接时间到运行时。只要可能,它动态的执行诸如创建对象和决定引用那个方法之类的操作。这意味着这种语言不仅仅需要一个编译器,并且需要一个运行时系统来执行编译过...
  • 华为C语言编程规范(精华总结)

    万次阅读 多人点赞 2020-03-24 09:48:55
    2、头文件 对于C语言来说,头文件的设计体现了大部分的系统设计。 不合理的头文件布局是编译时间过长的根因,不合理的头文件实际上反映了不合理的设计。 1、头文件中适合放置接口的声明,不适合放置实现 头文件是...
  • C语言面向对象编程

    2017-07-28 10:25:27
    嵌入式编程时的面向对象
  • 00. 目录 文章目录00. 目录01. 前言02. 简单程序示例03. 程序示例优化04. 总结05....01. 前言 面向对象编程(OOP)并不是一种特定的语言或者工具,它只是一种设计方法、设计思想。...C语言不是面向对象的语言,因此使

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 81,288
精华内容 32,515
关键字:

面向对象的c语言编程

c语言 订阅