C/C++函数

1 /* fopen example */
2 #include <stdio.h>
3 int main ()
4 {
5    FILE * pFile;
6    pFile = fopen ("myfile.txt","w");
7    if (pFile!=NULL)
8    {
9      fputs ("fopen example",pFile);
10      fclose (pFile);
11   }
12   return 0;
13 }

FILE*input;
input = fopen("data3", "r");
if (NULL == input)
{
    perror("data3");
    exit(EXIT_FAILURE);
}

功能：关闭一个流
头文件：#include<stdio.h>

原型：int fclose(FILE*f);
返回值：对于输出流，fclose函数会在文件关闭前刷新缓冲区，
              如果它执行成功，fclose返回0，否则返回EOF（-1）。

（如果流为NULL，而且程序可以继续执行，fclose设定error number给EINVAL，并返回EOF。）

/*这是一个调用fork()函数创建子进程的实例,当创建成功之后会分别打印两者对应的进程标志符*/
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>

int main(int argc,char *argv[])
{
  pid_t pid;        //进程标识符
  pid = fork();     //创建一个新的进程
  if(pid<0)
    {
    printf("创建进程失败!");
    exit(1);
    }
  else if(pid==0)   //如果pid为0则表示当前执行的是子进程
    printf("这是子进程,进程标识符是%d\n",getpid());
  else          //否则为父进程
    printf("这是父进程,进程标识符是%d\n",getpid());
  return 0;
}

/*这是一个调用fork()函数创建一个子进程,然后分别打印输出子进程和父进程中的变量的实例*/
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
int glob = 6;
int main(int argc,char *argv[])
{
    int var;    //内部变量
    pid_t pid;      //文件标识符
    var = 88;   //内部变量赋值
    printf("创建新进程之前.\n");   //还没有创建子进程
    if((pid=fork())<0)
    {
      perror("创建子进程失败!\n");
    }
    else if(pid==0)
    {
      glob++;
      var++;
    }
    else
    {
      sleep(2); //父进程阻塞两秒
    }
    printf("进程标识符为=%d,glob=%d,var=%d\n",getpid(),glob,var);//分别在子进程中输出两个变量的值
    exit(0);
}

•       handle 是文件描述符；
•       buf 是指定的缓冲区，即指针，指向一段内存单元；
•       nbyte 是要写入文件指定的字节数；返回值：写入文档的字节数（成功）；-1（出错）

•     str是字符指针或字符数组，用来存放一个字符串。
•     n是int型数，它用来表示输出显示字符串中字符的个数。

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys\stat.h>
#include <io.h>
#include <string.h>
int main(void)
{
    int *handle; char string[40];
    int length, res;

    /* Create a file named "TEST.$$$" in the current directory and write a string to it. If "TEST.$$$" already exists, it will be overwritten. */

    if ((handle = open("TEST.$$$", O_WRONLY | O_CREAT | O_TRUNC, S_IREAD | S_IWRITE)) == -1)
    {
        printf("Error opening file.\n");
        exit(1);
    }

    strcpy(string, "Hello, world!\n");
    length = strlen(string);

    if ((res = write(handle, string, length)) != length)
    {
        printf("Error writing to the file.\n");
        exit(1);
    }

    printf("Wrote %d bytes to the file.\n", res);
    close(handle); 

    return 0; 
}

1.      读取普通文件时，读到文件末尾还不够 nbytes 字节。例如：如果文件只有 30 字节，而我们想读取 100 字节，那么实际读到的只有 30 字节，read 函数返回 30 。此时再使用 read 函数作用于这个文件会导致 read 返回 0 。
2.     从终端设备（terminal device）读取时，一般情况下每次只能读取一行。
3.     从网络读取时，网络缓存可能导致读取的字节数小于 nbytes 字节。
4.     读取 pipe 或者 FIFO 时，pipe 或 FIFO 里的字节数可能小于 nbytes 。
5.     从面向记录（record-oriented）的设备读取时，某些面向记录的设备（如磁带）每次最多只能返回一个记录。
6.     在读取了部分数据时被信号中断。

// Code...

char *Ptr = NULL;
Ptr = (char *)malloc(100 * sizeof(char));

if (NULL == Ptr)
{
    exit (1);
}

gets(Ptr);

// code...

free(Ptr);

Ptr = NULL;

// code...

1. 申请了内存空间后，必须检查是否分配成功。
2. 当不需要再使用申请的内存时，记得释放；释放后应该把指向这块内存的指针指向NULL，防止程序后面不小心使用了它。
3. 这两个函数应该是配对。如果申请后不释放就是内存泄露；如果无故释放那就是什么也没有做。释放只能一次，如果释放两次及两次以上会出现错误（释放空指针例外，释放空指针其实也等于啥也没做，所以释放空指针释放多少次都没有问题）。
4. 虽然malloc()函数的类型是(void *),任何类型的指针都可以转换成(void *),但是最好还是在前面进行强制类型转换，因为这样可以躲过一些编译器的检查。

struct mem_control_block {
    int is_available;    //一般来说应该是一个可用空间的首地址，但这里英文单词却显示出空间是否可用的一个标记
    int size;        //这是实际空间的大小
};

void free(void *ptr) 
{
     struct mem_control_block *free;
     free = ptr - sizeof(struct mem_control_block);
     free->is_available = 1;
     Return 0;
}

• 内存分配

• 构造函数

• 析构函数

• 内存释放

class T{
public:
    T(){
        cout << "构造函数。" << endl;
    }

    ~T(){
        cout << "析构函数。" << endl;
    }

    void * operator new(size_t sz){

        T * t = (T*)malloc(sizeof(T));
        cout << "内存分配。" << endl;

        return t;
    }

    void operator delete(void *p){

        free(p);
        cout << "内存释放。" << endl;

        return;
    }
};

int main()
{
    T * t = new T(); // 先 内存分配 ，再 构造函数

    delete t; // 先 析构函数， 再 内存释放

    return 0;
}

class Test{
public:
    Test(){
        str = new char[2];
    }
    ~Test(){
        delete [] str;
    }
private:
    char * str;
};

int main(){

    // ①
    Test * t = new Test;
    free(t);

    // ②
    Test * t2 = (Test*)malloc(sizeof(Test));
    delete t2;

    return 0;
}

• Test 对象本身的内存( Win32环境，4 Bytes 存储 char * 指针）；
• str 所指向的 2 bytes 堆内存。

class Arena {
public:
        void * allocate(size_t);
        void deallocate(void\*);
          .... 
};
void * operator new(size_t sz, Arena& a)
{
      return a.allocate(sz);
}
Arena a1(some arguments);
Arena a2(some arguments);

X* p1 = new(a1) X;
Y* p2 = new(a1) Y;
Z* p3 = new(a2) Z;

#include <iostream>

using namespace std;

class Test{
public:
    Test(){
        cout << "Test 构造" << endl;
        str = new char[2];
    }
    ~Test(){
        cout << "Test 析构" << endl;
        delete [] str;
    }
private:
    char * str;
};

int main(int argc, char* argv[])
{
    char buf[100];  // 栈变量
    Test *p = new(buf) Test(); // Test()产生的临时变量用于初始化 指定内存地址

    p->~Test(); // 一定要主动调用析构函数，避免内存泄漏。 而且调用必须在 buf 生命周期内调用才有效。

    // buf 指向的栈内存并不需要程序员主动释放。
    // 栈变量过了生命周期会自动释放内存
    // 其实栈内存的释放也不叫内存释放，只是栈顶指针移动，如果该块栈内存没有被其他程序刷新，那么该栈内存的值依然不变。


    char * buf2 = new char[100];
    Test * p2 = new(buf2) Test();

    p2->~Test(); // 切记，主动调用析构函数

    delete [] buf2; // 堆内存需要主动释放

    return 0;
}

Test 构造

new (nothrow) Type ( optional-initializer-expression-list );

new (nothrow) Type[size];    // new (std::nothrow_t) Type[size];

void destroy (T * p, A & arena)
{
    // *p 是在 arena 之上构建的对象，即 T * a = new(&arena) T; 
    p->~T() ;             // 先析构 *p 对象
    arena.deallocate(p) ;  // 再释放 arena 整个内存，而不是位于arena中的部分内存（*p）
}
A arena ;
T * p = new (arena) T ;
....
destroy(p, arena) ;

A arena ;
T * p = new (arena) T ;
/* ... */

p->~T() ;                      // 先析构
operator delete(p, arena) ;   // 调用 placement delete 函数（非运算符）

// Then call the deallocator function indirectly via 
operator delete(void *, A &) .

#include <cstdlib>
#include <iostream>

char buf[100];
struct A {} ;
struct E {} ;

class T {
public:
    T() 
    { 
        std::cout << "T 构造函数。" << std::endl;
        throw E(); //抛出异常
    }

    void * operator new(std::size_t,const A &)
    {
        std::cout << "Placement new called for class T." << std::endl;
        return buf;
    }

    void operator delete(void*, const A &)
    {
        std::cout << "Placement delete called for class T." << std::endl;
    }
} ;

void * operator new ( std::size_t, const A & )
    {
        std::cout << "Placement new called." << std::endl; 
        return buf;
    }

void operator delete ( void *, const A & )
    {
        std::cout << "Placement delete called." << std::endl;
    }

int main ()
{
    A a ;
    try {
        T * p = new (a) T ;
        /* do something */
    } 
    catch (E exp) 
    {
        std::cout << "Exception caught." << std::endl;
    }

    return 0 ;
}

~delete 类对象时该注意的问题

class A
{
public:
    A(){}
    virtual void f(){}

private:
    int m_a;
};

class B : public A
{
public:
    virtual void f(){}
private:
    int m_b;
};

int main()
{
    A *pa = new B;
    delete pa;

    pa = NULL;

    return 0;
}

class A
{
public:
    A(){
        m_a = new int(1);
    }
    ~A(){  // 声明为virtual, 防止内存泄漏
        delete m_a;
    }

private:
    int * m_a;
};

class B : public A
{
public:
    B() : A(){
        m_b = new int(2);
    }

    ~B(){
        delete m_b;
    }

private:
    int * m_b;
};

int main()
{
    A * pa = new B;
    delete pa;

    pa = NULL;

    return 0;
}

~operator new/delete() 的函数重载

• operator new(size_t )函数的参数是一个 size_t 类型，指明了需要分配内存的规模。
• operator new(size_t )函数可以被每个 C++ 类作为成员函数重载。也可以作为全局函数重载：

void * operator new (std::size_t) throw(std::bad_alloc);
void operator delete(void*) throw();

struct E{};

class T{
public:
    T(){
        cout << "构造函数。" << endl;
        throw E();
    }

    ~T(){
        cout << "析构函数。" << endl;
    }

    void * operator new(size_t sz){

        T * t = (T*)malloc(sizeof(T));
        cout << "内存分配。" << endl;

        return t;
    }

    void operator delete(void *p){

        free(p);
        cout << "内存释放。" << endl;

        return;
    }
};

int main()
{

    try {
        T * p = new T;
        /* do something */
    }
    catch (E exp){
        std::cout << "Exception caught." << std::endl;
    }

    return 0;
}

void * operator new [] (std::size_t) throw(std::bad_alloc);
void operator delete [](void*) throw();

// Default placement versions of operator new.
inline void* operator new(std::size_t, void* __p) throw() { return __p; }
inline void* operator new[](std::size_t, void* __p) throw() { return __p; }

// Default placement versions of operator delete.
inline void  operator delete  (void*, void*) throw() { }
inline void  operator delete[](void*, void*) throw() { }

inline void* operator new(std::size_t, A * /* 或者 const A &*/); 
inline void* operator new[](std::size_t, A * /* 或者 const A &*/);

inline void  operator delete  (void*, A* /* 或者 const A &*/);
inline void  operator delete[](void*, A* /* 或者 const A &*/);

void* operator new(std::size_t, const std::nothrow_t&) throw();
void* operator new[](std::size_t, const std::nothrow_t&) throw();

void operator delete(void*, const std::nothrow_t&) throw();
void operator delete[](void*, const std::nothrow_t&) throw();

void * operator new(std::size_t size) throw(std::bad_alloc) {
    if (size == 0)
        size = 1;
    void* p;
    while ((p = ::malloc(size)) == 0) {
        std::new_handler nh = std::get_new_handler();
        if (nh)
            nh();
        else
            throw std::bad_alloc();
    }
    return p;
}

void operator delete(void* ptr) {
    if (ptr)
        ::free(ptr);
}

inline _LIBCPP_INLINE_VISIBILITY void* operator new (std::size_t, void* __p) _NOEXCEPT 
{
    return __p;
}

~小结

• 内存申请 new

• 构造函数。

• 析构对象。
• 内存释放 delete。

• 解决不能主动调用构造函数的“矛盾”。
• 对应的函数是 operator new(size_t , void *)。

• 没有此类运算符。
• 但有带位置的 placement delete 函数，如全局的 operator delete(void *,void*) 。