open和fopen的区别

Posted 2020-10-25 AlanTu

open和fopen的区别：

1.缓冲文件系统
缓冲文件系统的特点是：在内存开辟一个“缓冲区”，为程序中的每一个文件使用，当执行读文件的操作时，从磁盘文件将数据先读入内存“缓冲区”， 装满后再从内存“缓冲区”依此读入接收的变量。执行写文件的操作时，先将数据写入内存“缓冲区”，待内存“缓冲区”装满后再写入文件。由此可以看出，内存 “缓冲区”的大小，影响着实际操作外存的次数，内存“缓冲区”越大，则操作外存的次数就少，执行速度就快、效率高。一般来说，文件“缓冲区”的大小随机器 而定。
fopen, fclose, fread, fwrite, fgetc, fgets, fputc, fputs, freopen, fseek, ftell, rewind等
2.非缓冲文件系统
缓冲文件系统是借助文件结构体指针来对文件进行管理，通过文件指针来对文件进行访问，既可以读写字符、字符串、格式化数据，也可以读写二进制数 据。非缓冲文件系统依赖于操作系统，通过操作系统的功能对文件进行读写，是系统级的输入输出，它不设文件结构体指针，只能读写二进制文件，但效率高、速度 快，由于ANSI标准不再包括非缓冲文件系统，因此建议大家最好不要选择它。本书只作简单介绍。open, close, read, write, getc, getchar, putc, putchar 等。

open 是系统调用 返回的是文件句柄，文件的句柄是文件在文件描述副表里的索引，fopen是C的库函数，返回的是一个指向文件结构的指针。

fopen是ANSIC标准中的C语言库函数，在不同的系统中应该调用不同的内核api 
linux中的系统函数是open，fopen是其封装函数，个人观点。仅供参考。

文件描述符是linux下的一个概念,linux下的一切设备都是以文件的形式操作.如网络套接字、硬件设备等。当然包括操作文件。
fopen是标准c函数。返回文件流而不是linux下文件句柄。

设备文件不可以当成流式文件来用，只能用open
fopen是用来操纵正规文件的，并且设有缓冲的，跟open还是有一些区别

一般用fopen打开普通文件，用open打开设备文件

fopen是标准c里的,而open是linux的系统调用.
他们的层次不同.
fopen可移植,open不能

我认为fopen和open最主要的区别是fopen在用户态下就有了缓存，在进行read和write的时候减少了用户态和内核态的切换，而open则每次都需要进行内核态和用户态的切换；表现为，如果顺序访问文件，fopen系列的函数要比直接调用open系列快；如果随机访问文件open要比fopen快。

来自论坛的经典回答：

前者属于低级IO，后者是高级IO。
前者返回一个文件描述符(用户程序区的)int，后者返回一个文件指针FILE*。
前者无缓冲，后者有缓冲。
前者与 read, write 等配合使用， 后者与 fread, fwrite等配合使用。
后者是在前者的基础上扩充而来的，在大多数情况下，用后者。

 

 

smartPtr指针的实现

编写一个智能指针类。智能指针是一种数据类型，一般用模板实现，模拟指针行为的同时还提供自动来及回收机制。它会自动记录SmartPointer<T*>对象的引用计数，一旦T类型对象的引用计数为零，就会释放该对象。

解法：

智能指针跟普通指针一样，但它借由自动化内存管理保证了安全性，避免了诸如悬挂指针、内存泄漏和分配失败等问题。

智能指针必须为给定对象的所有引用维护单一引用计数。

实现代码：

 

template<class T>
class SmartPointer
{
public:
    SmartPointer(T* ptr)
    {
        ref=ptr;
        ref_count=(unsigned*)malloc(sizeof(unsigned));
        *ref_count=1;
    }
    
    
    SmartPonter(SmartPointer &rhs)
    {
        ref=rhs.ref;
        ref_count=rhs.ref_count;
        ++(*ref_count);
    }
        
    SmartPointer& operator=(SmartPointer& rhs)
    {
        if(*this==rhs)
            return *this;
        if(ref_count>0)
            remove();
        ref=rhs.ref;
        ref_count=obj.ref_count;
        ++(*ref_count);
        return *this;
    }

    ~SmartPointer()
    {
        remove();
    }
    
    T getValue()
    {
        return *ref;
    }
    
protected:
    void remove()
    {
        --(*ref_count);
        if(*ref_count==0)
        {
            delete ref;
            free(ref_count);
            ref=NULL;
            ref_count=NULL;
        }
    }
    T *ref;
    unsigned *ref_count;
};

 

 

shared_ptr的简单实现

前面讲到auto_ptr有个很大的缺陷就是所有权的转移,就是一个对象的内存块只能被一个智能指针对象所拥有.但我们有些时候希望共用那个内存块.于是C++ 11标准中有了shared_ptr这样的智能指针,顾名思义,有个shared表明共享嘛.所以shared_ptr类型的智能指针可以做为STL容器的元素

 

下面我们来瞧瞧shared_ptr具体是咋实现的.相较auto_ptr有下面几个不同的地方:

1.引进了一个计数器shared_count,用来表示当前有多少个智能指针对象共享指针指向的内存块

2.析构函数中不是直接释放指针对应的内存块,如果shared_count大于1则不释放内存只是将引用计数减1,只是计数等于1时释放内存

3.复制构造与赋值操作符只是提供一般意义上的复制功能,并且将引用计数加1.

 

shared_ptr实现代码(只实现核心功能)

#include <iostream>

using namespace std;

template<class T>

class shared_ptr{

private:

T* m_ptr; //被封装的指针

unsigned int shared_count;   //引用计数,表示有多少个智能指针对象拥有m_ptr指向的内存块

public:

shared_ptr(T* p):m_ptr(p),shared_count(1){ }

~shared_ptr() { deconstruct();}

void deconstruct(){

if(shared_count == 1)   //引用计数为1表示只有一个对象使用指针指向的内存块了

{

delete m_ptr;

m_ptr = 0;

}

shared_count--;

}

T& operator*() { return *m_ptr;}

T* operator->() { return m_ptr;}

 

//复制构造函数

shared_ptr(shared_ptr& sp):m_ptr(sp.m_ptr),shared_count(sp.shared_count){

shared_count++;

}

//重载运算符=

shared_ptr& operator = (shared_ptr& sp){

sp.shared_count++;   

deconstruct();  //相当于先删掉左值,然后再通过右值赋值.

m_ptr = sp.m_ptr;

shared_count = sp.shared_count;

return *this;

}　

};

auto_ptr解析

　　auto_ptr是当前C++标准库中提供的一种智能指针，或许相对于boost库提供的一系列眼花缭乱的智能指针，　或许相对于Loki中那个无所不包的智能指针，这个不怎么智能的智能指针难免会黯然失色。诚然，auto_ptr有这样那样的不如人意，以至于程序员必须像使用”裸“指针那样非常小心的使用它才能保证不出错，以至于它甚至无法适用于同是标准库中的那么多的容器和一些算法，但即使如此，我们仍然不能否认这个小小的auto_ptr所蕴含的价值与理念。
　　auto_ptr的出现，主要是为了解决“被异常抛出时发生资源泄漏”的问题。即如果我们让资源在局部对象构造时分配，在局部对象析构时释放。这样即使在函数执行过程时发生异常退出，也会因为异常能保证局部对象被析构从而保证资源被释放。auto_ptr就是基于这个理念而设计，　这最早出现在C++之父Bjarne Stroustrup的两本巨著TC++PL和D&E中,其主题为"resource acquisition is initialization"(raii,资源获取即初始化)，然后又在Scott Meyer的<<More Effective C++>>中相关章节的推动下，被加入了C++标准库。
　　下面我就列出auto_ptr的源代码，并详细讲解每一部分。因为标准库中的代码要考虑不同编译器支持标准的不同而插入了不少预编译判断，而且命名可读性不是很强（即使是侯捷老师推荐的SGI版本的stl,可读性也不尽如人意），　这里我用了Nicolai M. Josuttis(<<The C++ standard library>>作者)写的一个auto_ptr的版本，并做了少许格式上的修改以易于分析阅读。

namespace std
{
    template<class T>
    class auto_ptr
    {
    private:
        T *ap;
    public:
        //constructor&destructor...........................(1)
        explicit auto_ptr(T* ptr=0) throw():ap(ptr) {}
        
        ~auto_ptr() throw()
        {
            delete ap;
        }
    
        //copy&assignment...................................(2)
        auto_ptr(auto_ptr& rhs) throw(): ap(rhs.release()) {}
        template<class Y>
        auto_ptr(autor_ptr<Y> rhs) throw():ap(rhs.release()) {}

        auto_ptr& operate=(auto_ptr& rhs) throw()
        {
            reset(rhs.release());
            return *this;
        }
        template<class Y>
        auto_ptr& operator=(auto_ptr<Y> &rhs) throw()
        {
            reset(rhs.release());
            return *this;
        }

        //Dereference.........................................(3)
        T& operator*() const throw()
        {
            return *ap;
        }
        T* operateor->() const throw()
        {
            return ap;
        }
        
        //Helper functions.......................................(4)
        //value access
        T* get() const throw()
        {
            return ap;
        }
        

        //release owership
        T* release() throw()
        {
            T* tmp(ap);
            ap=0;
            return tmp;
        }

        //reset value
        void reset(T* ptr=0) throw()
        {
            if(ap!=ptr)
            {
                delete ap;
                ap=ptr;
            }
        }

        //special conversions.................................(5)
        template<class Y>
        struct auto_ptr_ref
        {
            Y* yp;
            auto_ptr_ref(Y* rhs):yp(rhs) {}
        };
        
        auto_ptr(auto_ptr_ref<T> rhs) throw():ap(rhs.yp) {}
        auto_ptr& operator=(auto_ptr_ref<T> rhs) throw()
        {
            reset(rhs.yp);
            return *this;
        }
        template<class Y>
        operator auto_ptr_ref<Y>() throw()
        {
            return auto_ptr_ref<Y>(release());
        }
        template<class Y>
        operator auto_ptr<Y>() throw()
        {
            return auto_ptr<Y>(relsease());
        }
    };
}

1 构造函数与析构函数
auto_ptr在构造时获取对某个对象的所有权(ownership),在析构时释放该对象。我们可以这样使用auto_ptr来提高代码安全性：
int* p = new int(0);
auto_ptr<int> ap(p);
从此我们不必关心应该何时释放p，　也不用担心发生异常会有内存泄漏。
这里我们有几点要注意：
1) 因为auto_ptr析构的时候肯定会删除他所拥有的那个对象，所有我们就要注意了，一个萝卜一个坑，两个auto_ptr不能同时拥有同一个对象。像这样：
int* p = new int(0);
auto_ptr<int> ap1(p);
auto_ptr<int> ap2(p);
因为ap1与ap2都认为指针p是归它管的，在析构时都试图删除p,　两次删除同一个对象的行为在C++标准中是未定义的。所以我们必须防止这样使用auto_ptr.
2) 考虑下面这种用法：
int* pa = new int[10];
auto_ptr<int> ap(pa);
因为auto_ptr的析构函数中删除指针用的是delete,而不是delete [],所以我们不应该用auto_ptr来管理一个数组指针。
3) 构造函数的explicit关键词有效阻止从一个“裸”指针隐式转换成auto_ptr类型。

explicit构造函数只能用于直接初始化，不能用于拷贝初始化（加上了“=”）。

4) 因为C++保证删除一个空指针是安全的，　所以我们没有必要把析构函数写成：
~auto_ptr() throw() 
{
 if(ap) delete ap;
}

2 拷贝构造与赋值
与引用计数型智能指针不同的，auto_ptr要求其对“裸”指针的完全占有性。也就是说一个”裸“指针不能同时被两个以上的auto_ptr所拥有。那么，在拷贝构造或赋值操作时，我们必须作特殊的处理来保证这个特性。auto_ptr的做法是“所有权转移”，即拷贝或赋值的源对象将失去对“裸”指针的所有权，所以，与一般拷贝构造函数，赋值函数不同，　auto_ptr的拷贝构造函数，赋值函数的参数为引用而不是常引用(const reference).当然，一个auto_ptr也不能同时拥有两个以上的“裸”指针，所以，拷贝或赋值的目标对象将先释放其原来所拥有的对象。
这里的注意点是：
1) 因为一个auto_ptr被拷贝或被赋值后，　其已经失去对原对象的所有权，这个时候，对这个auto_ptr的提领(dereference)操作是不安全的。如下:
int* p = new int(0);
auto_ptr<int> ap1(p);
auto_ptr<int> ap2 = ap1;
cout<<*ap1; //错误，此时ap1只剩一个null指针在手了
这种情况较为隐蔽的情形出现在将auto_ptr作为函数参数按值传递，因为在函数调用过程中在函数的作用域中会产生一个局部对象来接收传入的auto_ptr(拷贝构造)，这样，传入的实参auto_ptr就失去了其对原对象的所有权，而该对象会在函数退出时被局部auto_ptr删除。如下：
void f(auto_ptr<int> ap){cout<<*ap;}
auto_ptr<int> ap1(new int(0));
f(ap1);
cout<<*ap1; //错误，经过f(ap1)函数调用，ap1已经不再拥有任何对象了。
因为这种情况太隐蔽，太容易出错了，　所以auto_ptr作为函数参数按值传递是一定要避免的。或许大家会想到用auto_ptr的指针或引用作为函数参数或许可以，但是仔细想想，我们并不知道在函数中对传入的auto_ptr做了什么，　如果当中某些操作使其失去了对对象的所有权，　那么这还是可能会导致致命的执行期错误。　也许，用const reference的形式来传递auto_ptr会是一个不错的选择。

2)我们可以看到拷贝构造函数与赋值函数都提供了一个成员模板在不覆盖“正统”版本的情况下实现auto_ptr的隐式转换。如我们有以下两个类
class base{};
class derived: public base{};
那么下列代码就可以通过，实现从auto_ptr<derived>到auto_ptr<base>的隐式转换，因为derived*可以转换成base*类型
auto_ptr<base> apbase = auto_ptr<derived>(new derived);

3) 因为auto_ptr不具有值语义(value semantic), 所以auto_ptr不能被用在stl标准容器中。
所谓值语义，是指符合以下条件的类型(假设有类A)：
A a1;
A a2(a1);
A a3;
a3 = a1;
那么
a2 == a1, a3 == a1
很明显，auto_ptr不符合上述条件，而我们知道stl标准容器要用到大量的拷贝赋值操作，并且假设其操作的类型必须符合以上条件。

3 提领操作(dereference)
提领操作有两个操作，　一个是返回其所拥有的对象的引用，　另一个是则实现了通过auto_ptr调用其所拥有的对象的成员。如：
struct A
{ 
 void f();
}
auto_ptr<A> apa(new A);
(*apa).f();
apa->f();
当然，　我们首先要确保这个智能指针确实拥有某个对象，否则，这个操作的行为即对空指针的提领是未定义的。

4 辅助函数
1) get用来显式的返回auto_ptr所拥有的对象指针。我们可以发现，标准库提供的auto_ptr既不提供从“裸”指针到auto_ptr的隐式转换(构造函数为explicit),也不提供从auto_ptr到“裸”指针的隐式转换，从使用上来讲可能不那么的灵活，　考虑到其所带来的安全性还是值得的。
2) release,用来转移所有权
3) reset，用来接收所有权，如果接收所有权的auto_ptr如果已经拥有某对象，　必须先释放该对象。

5 特殊转换
这里提供一个辅助类auto_ptr_ref来做特殊的转换，按照标准的解释，　这个类及下面4个函数的作用是：使我们得以拷贝和赋值non-const auto_ptrs，　却不能拷贝和赋值const auto_ptrs. 我无法非常准确的理解这两句话的意义，但根据我们观察与试验，应该可以这样去理解：没有这些代码，我们本来就可以拷贝和赋值non-const的auto_ptr和禁止拷贝和赋值const的auto_ptr的功能，　只是无法拷贝和赋值临时的auto_ptr(右值)，　而这些辅助代码提供某些转换，使我们可以拷贝和赋值临时的auto_ptr，但并没有使const的auto_ptr也能被拷贝和赋值。如下：
auto_ptr<int> ap1 = auto_ptr<int>(new int(0));
auto_ptr<int>(new int(0))是一个临时对象，一个右值，一般的拷贝构造函数当然能拷贝右值，因为其参数类别必须为一个const reference,　但是我们知道，auto_ptr的拷贝函数其参数类型为reference，所以，为了使这行代码能通过，我们引入auto_ptr_ref来实现从右值向左值的转换。其过程为：
1) ap1要通过拷贝 auto_ptr<int>(new int(0))来构造自己
2) auto_ptr<int>(new int(0))作为右值与现有的两个拷贝构造函数参数类型都无法匹配，也无法转换成该种参数类型
3) 发现辅助的拷贝构造函数auto_ptr(auto_ptr_ref<T> rhs) throw()
4) 试图将auto_ptr<int>(new int(0))转换成auto_ptr_ref<T>
5) 发现类型转换函数operator auto_ptr_ref<Y>() throw()，　转换成功，从而拷贝成功。
从而通过一个间接类成功的实现了拷贝构造右值（临时对象）
同时，这个辅助方法不会使const auto_ptr被拷贝，　原因是在第5步，　此类型转换函数为non-const的，我们知道，const对象是无法调用non-const成员的，　所以转换失败。当然，　这里有一个问题要注意，　假设你把这些辅助转换的代码注释掉，该行代码还是可能成功编译，这是为什么呢？debug一下，　我们可以发现只调用了一次构造函数，而拷贝构造函数并没有被调用，原因在于编译器将代码优化掉了。这种类型优化叫做returned value optimization，它可以有效防止一些无意义的临时对象的构造。当然，前提是你的编译器要支持returned value optimization。

　　可见，auto_ptr短短百来行的代码，还是包含了不少"玄机"的。 

 

以下代码摘录自More Effective C++

 

#ifndef AUTO_PTR_H
#define AUTO_PTR_H

template<typename T>
class auto_ptr
{
    public :
        //使用explicit关键字避免隐式转换
        explicit auto_ptr(T* p=0);

        ~auto_ptr();

        //使用另一个类型兼容的auto_ptr来初始化一个新的auto_ptr
        template<typename U>
        auto_ptr(auto_ptr<U>& rhs);

        template<typename U>
        auto_ptr<T>& operator=(auto_ptr<U>& rhs);

        T& operator*() const;
        T* operator->() const;

        //返回原始对象的指针
        T* get() const;
        //放弃指针的所以权
        T* release();
        //删除原有指针并获得指针的p的所有权
        void reset(T* p=0);

    private:
        T* pointee;

};

template<typename T>
auto_ptr<T>::auto_ptr(T* p)
    :pointee(p)
{}

template<typename T>
    template<typename U>
auto_ptr<T>::auto_ptr(auto_ptr<U>& rhs)
    :pointee(rhs.release())
{}

template<typename T>
auto_ptr<T>::~auto_ptr()
{
    delete pointee;
}

template<typename T>
    template<typename U>
auto_ptr<T>& auto_ptr<T>::operator=(auto_ptr<U>& rhs)
{
    if(this!=&rhs)
        reset(rhs.release());
    return *this;
}

template<typename T>
T& auto_ptr<T>::operator*() const
{
    return *pointee;
}

template<typename T>
T* auto_ptr<T>::operator->() const
{
    return pointee;
}

template<typename T>
T* auto_ptr<T>::get() const
{
    return pointee;
}

template<typename T>
T* auto_ptr<T>::release()
{
    T* oldpointee=pointee;
    pointee=0;
    return oldpointee;
}

template<typename T>
void auto_ptr<T>::reset(T* p)
{
    if(pointee!=p)
    {
        delete pointee;
        pointee=p;
    }
}

#endif