精华内容
下载资源
问答
  • C语言面向对象编程

    2018-06-01 16:47:30
    C语言面向对象编程技术,是C语言开发者不可多得的技术书籍
  • 此实例文件是文章《学会C语言面向对象编程,弄清面向对象实质。》的附件https://blog.csdn.net/weixin_42523774/article/details/105649779,是为了告诉大家如何用C语言实现面向对象的语言。
  • 此实例文件是文章《学会C语言面向对象编程,弄清面向对象实质。》的附件https://blog.csdn.net/weixin_42523774/article/details/105649779,是为了告诉大家如何用C语言实现面向对象的语言。
  • 飞机大战 C语言实现 使用C语言面向过程设计出一个飞机大战,可以发射子弹,敌机随机产生,我放飞机移动,碰撞检测等功能,注释很清晰,适合初学者学着敲。
  • C语言面向对象编程与设计模式
  • C语言面向对象程序设计(ppt) C语言面向对象程序设计(ppt) C语言面向对象程序设计(ppt)
  • C语言面向对象(针对较大型软件
  • c语言面向过程程序设计,简单又实用,能帮助你解决很多问题,你真的拥有
  • C语言面向对象程序设计7 当启动一个面向对象程序时, 程序将做: 创建对象; 通过消息处理对象, 即执行对象的方法, 删除对象; Windows应用程序的四种消息来源: 1. 输入消息: 鼠标键盘输入的消息 2. 控制消息: 用户改变...
  • C语言面向对象编程之基类。

    千次阅读 2017-10-24 17:24:43
    我们作为一个程序员,C语言...一开始,我们会发现,c语言里边会有结构体struct,和c++中的类是很相似的,同时C语言接头体里边可以包含函数指针,那么我们针对帧一点开始动手做自己的C语言面向对象lib。我们参考万物皆有

    说在前边

           我们作为一个程序员,C语言可以说是最开始入门的语言,它让我们接触了程序的奥妙,当我们慢慢的接触了C++,Java或者其他更加高级的语言时会发现C语言使用起来很不方便,其中之一就是,以我个人为例,一开始学习C语言是用来编写单片机程序的(面向过程的),在我初级印象当中,c语言是面向过程的。那么怎么样它具有面向对象的性质呢?一开始,我们会发现,c语言里边会有结构体struct,和c++中的类是很相似的,同时C语言接头体里边可以包含函数指针,那么我们针对帧一点开始动手做自己的C语言面向对象lib。我们参考万物皆有祖宗的思想写一个基类(Java的想法)。

         下面的代码是我在github上边找到的,各位可以在 github 上搜索 CSubSub 即可搜索到

    CSubSub

    基类头文件

    //
    //  cssObject.h
    //  CSubSub
    //
    //  Created by plters on 14-5-20.
    //  Copyright (c) 2014年 plter. All rights reserved.
    //
    
    
    #ifndef __CSubSub__cssObject__
    #define __CSubSub__cssObject__
    
    
    #ifdef __cplusplus
    extern "C" {
    #endif
    
    
    #include <stdio.h>
    #include <string.h>
    #include <stdlib.h>
    #include <time.h>
    
    
    void logOff();
    void logOn();
    void logOut(char * msg);
    
    
    #define cssClass(name) typedef struct name{name##Fields(struct name *)}name;
    ///对象转换,这里只能将子类转换成父类_宏定义
    #define cssAs(type,object) ((type)(object))
    ///对象内存给分配_宏定义
    #define cssAlloc(__class__) cssAs(__class__ *,malloc(sizeof(__class__)))
    ///对象内存个释放_宏定义
    #define cssDelloc(object) free(object)
    ///对象,结构体,内存给拷贝_宏定义 @Add by JasonHuo
    #define cssObjCpy(pObjSrc,pObjDst,TYPE) memcpy(pObjDst,pObjSrc,sizeof(TYPE))
    
    
    ///基类宏定义
    //TYPE is type of the class that you wanna to create
    #define cssObjectFields(TYPE) \
        int _retainCount;\
        void (*retain)(TYPE _this);\
        void (*release)(TYPE _this);\
        int (*retainCount)(TYPE _this);\
        void (*onDelloc)(TYPE _this);
    
    
    cssClass(cssObject)
    
    
    cssObject* cssObjectInit(cssObject *_this);
    
    
    #ifdef __cplusplus
    }
    #endif
    
    
    #endif /* defined(__CSubSub__cssObject__) */
    
    


    基类源文件

    //
    //  cssObject.c
    //  CSubSub
    //
    //  Created by plters on 14-5-20.
    //  Copyright (c) 2014年 plter. All rights reserved.
    //
    
    #include "cssObject.h"
    
    
    static int _isLogOn = 0;
    
    void logOff(){
    	_isLogOn = 0;
    }
    void logOn(){
    	_isLogOn = 1;
    }
    void logOut(char * msg){
    	if (_isLogOn) {
    		time_t t = time(NULL);
    		struct tm* tm = localtime(&t);
    		printf("[%d:%d:%d]%s\n",tm->tm_hour,tm->tm_min,tm->tm_sec,msg);
    	}
    }
    
    
    static void cssObjectRetain(cssObject *_this){
    	_this->_retainCount++;
    }
    
    static void cssObjectRelease(cssObject *_this){
    	_this->_retainCount--;
    	if (_this->_retainCount<=0) {
    		_this->onDelloc(_this);
    		cssDelloc(_this);
    	}
    }
    
    static int cssObjectRetainCount(cssObject *_this){
    	return _this->_retainCount;
    }
    
    static void cssObjectOnDelloc(cssObject *_this){
    	logOut("Destroy cssObject");
    }
    
    
    cssObject* cssObjectInit(cssObject *_this){
    	_this->_retainCount = 1;
    	_this->onDelloc = &cssObjectOnDelloc;
    	_this->release = &cssObjectRelease;
    	_this->retain = &cssObjectRetain;
    	_this->retainCount = &cssObjectRetainCount;
        
    	logOut("init cssObject");
    	return _this;
    }
    

    后面会使用这个基类来实现我们C++常用到的容器

    本文URL:http://blog.csdn.net/qq_21193563/article/details/78332069

    展开全文
  • C语言面向对象

    千次阅读 2017-08-30 17:01:24
    在我们的印象中,C语言是一个面向过程的语言。应该是和面向对象没有什么关系的。但是在我们的实际开发中,如果我们真的决定使用C语言来完成一个大型的项目的化。纯函数式的编程,纯面向过程式的设计还是会让代码很难...

    在我们的印象中,C语言是一个面向过程的语言。应该是和面向对象没有什么关系的。但是在我们的实际开发中,如果我们真的决定使用C语言来完成一个大型的项目的化。纯函数式的编程,纯面向过程式的设计还是会让代码很难维护和理解的。

    所以一般的C语言项目中是或多或少会去尝试一些面向对象的设计的。那么用C 语言怎么实现面向对象呢?

    结构体+函数指针。基本就是这个套路了。

    比如我们想要定义一个Person 类。那么用Java的话,我们一般是这样定义的:

    public class Person {
        private String name;
        private int age;
    
        public Person(String name, int age) {
            this.name = name;
            this.age = age;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    
        public String getName() {
            return name;
        }
    
        public int getAge() {
            return age;
        }
    }

    使用的时候我们只需要这样使用即可

    Person person = new Person("jerry", 27);
    String name = person.getName();
    int age = person.getAge();
    person.setAge(50);
    person.setName("tom");

    那如果我们有C 语言的实现是怎么样呢?

    typedef struct _person{
        char name[128];
        int age;
        void (*setName)(struct _person * person, char* name);
        void (*setAge)(struct _person * pseron,int age);
        char *(*getName)(struct _person * person,int *len);
        int (*getAge)(struct _person * pseron);
    }Person;
    
    
    static void setName(struct _person * person, char* name){
        if(person == NULL)
            return;
        memcpy(person->name, name, strlen(name));
        return;
    }
    
    static void setAge(struct _person * person,int age){
        if(person == NULL)
            return;
        person->age = age;
        return;
    }
    static char * getName(struct _person * person, int *len){
        if(person == NULL)
            return NULL;
        *len = strlen(person->name);
        return person->name;
    }
    static int getAge(struct _person * person){
        if(person == NULL)
            return -1;
        return person->age;
    }
    
    Person * Person_new(char * name, int age){
        Person * person = NULL;
        person = (Person *)malloc(sizeof(Person));
        memset(person, 0, sizeof(Person));
    
        person->getAge = getAge;
        person->getName = getName;
        person->setName = setName;
        person->setAge = setAge;
    
        memcpy(person->name, name, strlen(name));
        person->age = age;
        return person;
    }
    
    void Person_delete(Person * person){
        if(person == NULL)
            return;
        free(person);
        return;
    }

    使用时代码这样编写

        Person * person = Person_new("jerry", 27);
        person->setAge(person, 50);
        person->getAge(person);
        int len;
        printf("person name : %s, age: \n", person->getName(person, &len), person->getAge(person));
        Person_delete(person);
        person = NULL;

    然后我们发现,在Java中我们不需要把person 本身作为参数传递给Person 类的方法。但是再C里面我们需要为每一个函数传递一个Person 结构体指针。因为在函数中如果操作Person 结构体的成员的话,必须要能访问到person ,所以我们要把这个结构体指针传入函数中。这样一看,感觉好像C 语言实现起来好别扭,其实不然。其实在Java 中如果我们要访问Person 类的成员,我们同样需要一个指向Person 对象的引用。只不过这一引用表现的比较含蓄,它就是this 关键字。而传入引用这个动作也不用我们在代码中显示的写出来。但我们完全可以把他们看成是一样的。Java的this 就是C里面的 person。这样是不是整个逻辑就通了。

    用C语言来表达面向对象的思想就是这么简单。没有太大的花头。

    展开全文
  • C语言面向对象编程(doc格式,将docx格式转化成了doc格式)
  • 由于长期跟面向对象开发语言打交道,作为一个...以下记录一下花了一整晚写的c语言面向对象的代码。一、首先创建头文件object.h,该头文件是主要作用是定义面向对象一些关键字,代码如下#include &lt;stdlib.h...

    由于长期跟面向对象开发语言打交道,作为一个c语言入门者(差不多零基础哭),接触C语言最大疼点就是不习惯面向过程的开发。为了快速上手c语言,还是使用自己习惯编程思维去开发。这次主要针对面向对象封装、继承、多态3大特点进行实现。以下记录一下花了一整晚写的c语言面向对象的代码。


    一、首先创建头文件object.h,该头文件是主要作用是定义面向对象一些关键字,代码如下

    #include <stdlib.h>
    #include <string.h>
    #include "base.h"
    #ifndef OBJECT_H
    #define OBJECT_H
    
    
    //
    #define PUBLIC ;
    #define PRIVATE(PrivateName) struct PrivateName
    #define CLASS(ClassName) struct ClassName
    #define THIS(ClassName) CLASS(ClassName)*this
    #define PLACEHOLDER(ClassName) char placeholder[sizeof(CLASS(ClassName))-sizeof(char*)] //substract first pointer size
    //memory define
    #define NEW(type) ((type*)malloc(sizeof(type)))
    #define DELETE(memory) free(memory)
    
    
    static void setValue(void* property, void* value,U32 len)
    {
        memcpy(property, value,len);
    }
    static void getValue(void* property, void* value,U32 len)
    {
        memcpy(value, property,len);
    }
    #endif


    上述代码中PUBLIC、PRIVATE、CLASS、THIS、NEW、DELETE为面向对象语言最常见的关键字,定义的目的为了简化书写及方便理解,并实现本次面向对象的功能。以下介绍一下各个关键字作用:

    PUBLIC:定义公共的变量及函数,使外部能进行访问

    PRIVATE:通过在private.h头文件中定义不开放变量及函数,达到对象封装的效果

    CLASS:定义一个结构体,用作类信息定义

    THIS:将CLASS的第一个成员this指向自己,目的为了在继承的时候,通过this找到基类的成员。

    NEW:为类分配空间,实例化对象

    DELETE:删除分配的空间,跟NEW成对出现

    setValue,getValue为数据的get、set函数,用于对象数据获取与设置

    注:PLACEHOLDER是后来加上去的,博主在使用过程中发现子类不能定义变量和函数指针,原因是子类的私有变量使用了THIS后面的地址空间,结果直接覆盖了父类的内存,所以增加PLACEHOLDER做占位用,使子类定义的变量和函数指针能指向正确的地址

    二、创建基类person.h,根据面向对象类定义的实现封装效果

    #include <stdlib.h>
    #include <string.h>
    #include "../../../base/include/object.h"
    #include "person.h"
    #ifndef MAN_H
    #define MAN_H
    
    
    CLASS(Man);
    
    
    PUBLIC void Man_constructor(CLASS(Man)*);
    PUBLIC void setname_man(CLASS(Person)* self,char* str);
    PUBLIC void getname_man(CLASS(Person)* self,char* str);
    
    
    CLASS(Man){
        THIS(Person);
        PLACEHOLDER(Person);//fix memory overwrite bug
    };
    
    
    void testMan();
    #endif

    这里代码有点多,我简单说明一下思法:

    person_private.h主要是私有类型,里面定义的内容不开放给外部,内容主要如下:

    #include <string.h>
    #include "../../../base/include/object.h"
    
    
    #ifndef PERSON_PRIVATE_H
    #define PERSON_PRIVATE_H
    
    
    PRIVATE(Person_Private);
    PRIVATE(Person_Private)
    {
        int age;
        char name[255];
    };
    
    
    #endif

    CLASS(Person),这里定义一个类信息,其中THIS为当前类实例的指针

    Person_constructor为构造函数,主要初始化CLASS(Person)对象信息,如绑定setage、getage、setname、getname各种函数

    三、用上面person封装思想来创建子类man.h,并实现面向对象继承及多态的特性

    #include <stdlib.h>
    #include <string.h>
    #include "../../../base/include/object.h"
    #include "person.h"
    #ifndef MAN_H
    #define MAN_H
    
    CLASS(Man);
    
    PUBLIC void Man_constructor(CLASS(Man)*);
    PUBLIC void setname_man(CLASS(Person)* self,char* str);
    PUBLIC void getname_man(CLASS(Person)* self,char* str);
    
    CLASS(Man){
        THIS(Person);
    };
    
    
    PUBLIC void Man_constructor(CLASS(Man)*self)
    {
        self->this=(CLASS(Person)*)self;
        Person_constructor(self->this);
        self->this->getName=getname_man;
        self->this->setName=setname_man;
    }
    
    PUBLIC void setname_man(CLASS(Person)* self,char* str)
    {
        str = strcat(str, " man set");
        setValue(self->private.name,str, strlen(str)+1);
    }
    PUBLIC void getname_man(CLASS(Person)* self,char* str)
    {
        getValue(self->private.name, str, strlen(self->private.name)+1);
        strcat(str, " man get");
    }
    
    void testMan();
    #endif
    由上面代码可以看出,子类的代码比父类少了很多,这就是面向对象的好处了 大笑。这里也是简单地说明一下:

    THIS(Person)作用是将子类地址入口指向CLASS(Man)的第一个成员,用这个做法可以通过CLASS(Person)*强制转换CLASS(Man)对象。

    Person_constructor(self->this)作用是子类被实例化构造时,对基类也进行实例化。这里就是继承了,是不是很简单呢。

    self->this->getName=getname_man和self->this->setName=setname_man就是面向对象多态的实现,其实就是覆盖父类的方法(高级语言叫重写)

    四、实现man.c和oo.c,看看面向对象实现的效果吧

    man.c代码如下

    #include <stdio.h>
    #include "../include/man.h"
    void testMan()
    {
        CLASS(Man)* man = NEW(CLASS(Man));//new
        Man_constructor(man);//构造函数    
        CLASS(Person)* person=(CLASS(Person)*)man;
        char str[255]="person";
        person->setName(person,(char*)str);
        char name[255];
        person->getName(person,name);
        person->setAge(person,20);
        int age = person->getAge(person);
        DELETE(man);
        printf("%s",name);
        printf("%d",age);
        fflush(stdout); 
    }
    oo.c代码如下

    #include <stdio.h>
    
    int main(int argc,char* argv[])
    {
        testMan();
        return 0;
    }
    下面是调用执行的结果,可以看出这里成功打印子类的信息及继承父类的信息,证明这次面向对象实现是成功的


    另外需要补充说明一下,为了方便文中类定义都是头文件中完成,实际项目应放在具体的c文件里面,原因是避免编译时出现重复定义的问题

    展开全文
  • Java面向对象与c语言面向过程的不同 面向过程和面向对象的区别: 面向对象和面向过程,其实就是关注一件事情的角度不同,比如说:你想看AV(AmericanVideo) 面向过程是: 面向对象是: ...
    

    Java面向对象与c语言面向过程的不同

    1. 面向过程和面向对象的区别:

      面向对象和面向过程,其实就是关注一件事情的角度不同,比如说:你想看AVAmericanVideo

      面向过程是:

      面向对象是:

      从上面两张图不难看出,面向过程是一个自给自足的过程,它需要考虑第一步干什么,第二步干什么。。。

      而面向对象是直接无视过程,不关注他是怎么实现的,或者说是利用一个包装好的过程来实现自己想要达到的目的。。比如说:我要看AV,我不管你在哪下载谁给你种子,还是用暴影还是Q影还是射手还是快播来搞给我看,我不管,我就是要看AV

      Java面向对象的三个基本特征是类,

    2. 对象和类

      这也是面向对象语言比面向过程语言高级的地方,面向对象编程会比面向过程接近人类社会的思维方式,使程序员编程更加快捷和方便。

      如:AoisoraYui Hatano是对象,而他们都是日本人,日本人就是一个类。

      从上例不难看出,对象就是具体到某一事物上,而类就是对象的类别(也就是所谓的抽象),当然,对象也可以归属到不同的类。

       

      而每个事物都有自己的属性和行为,如:小何身高一米八五,具有打篮球、踢足球、编程的能力。

      身高就是小何的属性,从编程的角度来说可以用变量来描述。

      打篮球,踢足球,编程的能力就是小何的行为,从编程的角度来说可以用方法来描述。

       

    3. 继承

      现实世界中事物的属性和行为可以进行传递,当某一个事物得到了另一个失误传给它的属性和行为时,我们就说该事物实现了继承。

      如:小何的孩子小小何会继承父亲某些属性和行为,小小何身高也是一米八五,同样能打球,踢球,编程,还能把高数刷到100分!

      小小何继承了小何的某些属性和行为时,我们就说该事物实现了继承。

      继承不同于复制,上例中可看出,小小何还有高数刷分的技能,这就是他比他父亲高超的地方。

      被继承的对象是父类,继承父类的对象叫子类。

      通过继承来重用已有代码,同时增加新的代码来拓展功能,达到不浪费代码的目的。

       

    4. 多态

      多态是指同一个名字的若干个方法(方法体中的代码不一样,但是实现的功能类似,所以他们是同一个名字)。我们用一个方法名调用方法时,执行的是这些不同版本中的一种。

      多态分为重载和覆盖

    1. 重载

      一个类中,有若干方法名字想同,但参数不同,成为方法(functions)的重载。在调用时根据参数的不同来决定执行哪个方法。

      重载的关键是参数必须不同(参数的类型或个数必须不同)

      如:有个计算加法的方法,该方法既可以计算2个整数相加,也能计算2个浮点数相加,也能实现3个整数的相加,相比c语言,重载用起来方便得多。

                                  publicint a2b(int a,int b)

                                  publicfloat a2b(float a,float b)

                                  publicint a2b(int a,int b,int c)

    2. 覆盖

      声明:覆盖是发生在子类中的。也就是说必须有继承才会有覆盖的发生。

      覆盖的定义:如果子类和父类有同名的方法(且参数相同),子类中的方法将覆盖父类的方法。

      也就是说你对一个父类的功能不爽,然后对该父类再写一遍写代码写到你爽到嗨来产生一个子类,下次你调用这个方法的时候就会用子类的方法来覆盖父类的方法。

       

    1. 接口

      Java中的类只能有一个父类(只能进行单重继承,c++可以多重),这样的程序结构简单,层次清楚,但是实际应用中往往需要多重继承,因此Java提供接口来实现多重继承。

      接口是一种特殊的类,它只能由常量和抽象方法组成,而不包含变量和方法的实现。

      一个接口可以被一个或者多个类实现,当一个类实现了一个接口,它必须实现接口中所有的方法,这些方法必须被声明为public

    展开全文
  • C语言面向对象编程(doc格式,非英文翻译版) C语言面向对象编程(doc格式,非英文翻译版)
  • C语言面向对象程序设计的课件,希望对广大网友有用处,谢谢!!
  • 轻量级的C语言面向对象编程框架

    千次阅读 2014-05-24 00:13:13
    轻量级的C语言面向对象编程框架
  • C语言写的面向对象框架的内核部分,由于刚刚开始写,内容仅包含底层核心。本来不想要币的,但发现自己居然没币了,所以,大家支持下哈。。 ^_^
  • C语言是一门面向过程的编程语言,里面没有类的说法,没有类的继承、封装、多态。Cpp是有类的概念的,Cpp本身就来源C语言,Cpp的类就是一个经过高度封装的C语言结构体。在学习Cpp之前,了解C语言的设计模式非常重要,...
  • C语言面向对象的航班订票系统,使用文件存储,关键是文件读取怎么写?
  • C语言程序结构化程序设计方法;C++语言程序面向对象程序设;Time standard;为什么用类: 可以实现面向对象;class 类名 ;class 类名 { ;面向对象程序设计说明1. ;再看一个例子例1-2 ;class Human {;有成员函数和无成员函
  • 很多人认为,C语言编程,就是函数式编程,C++, JAVA等高级语言,才是面向对象编程。 其实,这是错误的认识!面向对象编程是一种思想,是一种编程思路,实现这种编程思路,不局限于是使用C语言还是使用C++语言。 ...
  • 这篇文章给出了我自己写的纯C语言面向对象开发的缓冲区模块
  • C语言面向对象的实现---继承性  在嵌入式系统开发中,不同的MCU一般都支持C编译器,而可能没有C++的编译器或支持的不好,所以,在嵌入式系统的开发中,C语言是使用最多的语言。而为了使用面向对象(OO)的优点,一般...
  • c语言面向对象设计

    2008-05-25 09:26:05
    本书是介绍c面向对象的一本好书
  • 用c++写的,没有文件操作的,利用面向对象思想的小通讯录。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 124,826
精华内容 49,930
关键字:

c语言面向

c语言 订阅