请问什么是托管c++程序

什么是托管C++

托管是.NET的一个专门概念，它倡导一种新的编程理念，因此我们完全可以把“托管”视为“.NET”。由托管概念所引发的C++应用程序包括托管代码、托管数据和托管类三个组成部分。

托管代码

.Net环境提供了许多核心的运行(RUNTIME)服务，比如异常处理和安全策略。为了能使用这些服务，必须要给运行环境提供一些信息代码(元数据)，这种代码就是托管代码。所有的C#、VB.NET、JScript.NET默认时都是托管的，但Visual C++默认时不是托管的，必须在编译器中使用命令行选项(/CLR)才能产生托管代码。

托管数据

与托管代码密切相关的是托管数据。托管数据是由公共语言运行的垃圾回收器进行分配和释放的数据。默认情况下，C#、Visual Basic 和 JScript.NET 数据是托管数据。不过，通过使用特殊的关键字，C# 数据可以被标记为非托管数据。Visual C++数据在默认情况下是非托管数据，即使在使用 /CLR 开关时也不是托管的。

托管类

尽管Visual C++数据在默认情况下是非托管数据，但是在使用C++的托管扩展时，可以使用“__gc”关键字将类标记为托管类。就像该名称所显示的那样，它表示类实例的内存由垃圾回收器管理。另外，一个托管类也完全可以成为 .NET 框架的成员，由此可以带来的好处是，它可以与其他语言编写的类正确地进行相互操作，如托管的C++类可以从Visual Basic类继承等。但同时也有一些限制，如托管类只能从一个基类继承等。

托管资源指的是.NET可以自动进行回收的资源，主要是指托管堆上分配的内存资源。托管资源的回收工作是不需要人工干预的，有.NET运行库在合适调用垃圾回收器进行回收。

非托管资源指的是.NET不知道如何回收的资源，最常见的一类非托管资源是包装操作系统资源的对象，例如文件，窗口，网络连接，数据库连接，画刷，图标等。这类资源，垃圾回收器在清理的时候会调用Object.Finalize()方法。默认情况下，方法是空的，对于非托管对象，需要在此方法中编写回收非托管资源的代码，以便垃圾回收器正确回收资源。

在.NET中，Object.Finalize()方法是无法重载的，编译器是根据类的析构函数来自动生成Object.Finalize()方法的，所以对于包含非托管资源的类，可以将释放非托管资源的代码放在析构函数。

注意，不能在析构函数中释放托管资源，因为析构函数是有垃圾回收器调用的，可能在析构函数调用之前，类包含的托管资源已经被回收了，从而导致无法预知的结果。

本来如果按照上面做法，非托管资源也能够由垃圾回收器进行回收，但是非托管资源一般是有限的，比较宝贵的，而垃圾回收器是由CRL自动调用的，这样就无法保证及时的释放掉非托管资源，因此定义了一个Dispose()方法，让使用者能够手动的释放非托管资源。Dispose()方法释放类的托管资源和非托管资源，使用者手动调用此方法后，垃圾回收器不会对此类实例再次进行回收。Dispose()方法是由使用者调用的，在调用时，类的托管资源和非托管资源肯定都未被回收，所以可以同时回收两种资源。

Microsoft为非托管资源的回收专门定义了一个接口：IDisposable，接口中只包含一个Dispose()方法。任何包含非托管资源的类，都应该继承此接口。

在一个包含非托管资源的类中，关于资源释放的标准做法是：

（1） 继承IDisposable接口；

（2） 实现Dispose()方法，在其中释放托管资源和非托管资源，并将对象本身从垃圾回收器中移除（垃圾回收器不在回收此资源）；

（3） 实现类析构函数，在其中释放非托管资源。

在使用时，显示调用Dispose()方法，可以及时的释放资源，同时通过移除Finalize()方法的执行，提高了性能；如果没有显示调用Dispose()方法，垃圾回收器也可以通过析构函数来释放非托管资源，垃圾回收器本身就具有回收托管资源的功能，从而保证资源的正常释放，只不过由垃圾回收器回收会导致非托管资源的未及时释放的浪费。

在.NET中应该尽可能的少用析构函数释放资源。在没有析构函数的对象在垃圾处理器一次处理中从内存删除，但有析构函数的对象，需要两次，第一次调用析构函数，第二次删除对象。而且在析构函数中包含大量的释放资源代码，会降低垃圾回收器的工作效率，影响性能。所以对于包含非托管资源的对象，最好及时的调用Dispose()方法来回收资源，而不是依赖垃圾回收器。

上面就是.NET中对包含非托管资源的类的资源释放机制，只要按照上面要求的步骤编写代码，类就属于资源安全的类。

下面用一个例子来总结一下.NET非托管资源回收机制：

Public class BaseResource:IDisposable

{

PRivate IntPtr handle// 句柄，属于非托管资源

Private Componet comp// 组件，托管资源

Private bool isDisposed = false// 是否已释放资源的标志

PublicBaseResource

{

}

//实现接口方法

//由类的使用者，在外部显示调用，释放类资源

Publicvoid Dispose()

{

Dispose(true)// 释放托管和非托管资源

//将对象从垃圾回收器链表中移除，

// 从而在垃圾回收器工作时，只释放托管资源，而不执行此对象的析构函数

GC.SuppressFinalize(this)

}

//由垃圾回收器调用，释放非托管资源

~BaseResource()

{

Dispose(false)// 释放非托管资源

}

//参数为true表示释放所有资源，只能由使用者调用

//参数为false表示释放非托管资源，只能由垃圾回收器自动调用

//如果子类有自己的非托管资源，可以重载这个函数，添加自己的非托管资源的释放

//但是要记住，重载此函数必须保证调用基类的版本，以保证基类的资源正常释放

Protectedvirtual void Dispose(bool disposing)

{

If(!this.disposed)// 如果资源未释放 这个判断主要用了防止对象被多次释放

{

If(disposing)

{

Comp.Dispose()// 释放托管资源

}

closeHandle(handle)// 释放非托管资源

handle= IntPtr.Zero

}

this.disposed= true// 标识此对象已释放

}

}析构函数只能由垃圾回收器调用。

Despose()方法只能由类的使用者调用。

在C#中，凡是继承了IDisposable接口的类，都可以使用using语句，从而在超出作用域后，让系统自动调用Dispose()方法。一个资源安全的类，都实现了IDisposable接口和析构函数。

提供手动释放资源和系统自动释放资源的双保险。

使用方法：

__________________________________________

#include "mempool.h"

#include <stdio.h>

int main() {

MemPool* pool = open_pool()//这个链表储存了所有指针信息。

char* str =NEW_STR(pool, 1024)//申请内存空间，并在pool中记录。

scanf("%s", str)printf("%s\n",str)

close_pool(pool)//释放所有申请的空间

return 0}

__________________________________________

#include <stdlib.h>

struct _MEM_TABLE_ {

void * pointer

struct _MEM_TABLE_* next

}

typedef struct _MEM_TABLE_ MemPool

typedef void (*FUNC_POOL_EACH)(MemPool*)

MemPool* open_pool(void)

void close_pool(MemPool*)

MemPool* __pool_bottom(const MemPool*)

void __pool_for_each(MemPool*, FUNC_POOL_EACH)

void __pool_alloc_memset(void*,size_t)

void* alloc_pool(MemPool*, size_t)

void delloc_pool(MemPool*, void*)

#define NEW_STR(pPool,len) ((char*)alloc_pool((pPool),(len)))

#define NEW_INT(pPool) ((int*)alloc_pool((pPool),sizeof(int)))

#define NEW_DOUBLE(pPool) ((double*)alloc_pool((pPool),sizeof(double)))

#define NEW_FLOAT(pPool) ((float*)alloc_pool((pPool),sizeof(float)))

#define NEW_TYPE(pPool, tType) ((tType*)alloc_pool((pPool),sizeof(tType)))

#define DELETE(pPool,p) (delloc_pool((pPool),(p)))

MemPool* open_pool(void) {

MemPool* p = malloc(sizeof(MemPool))

if (p != NULL) {

p->pointer = NULL

p->next = NULL

}

return p

}

void close_pool(MemPool* p) {

MemPool* now = p, *tmp

while (now != NULL) {

tmp = now

now = now->next

if (tmp->pointer != NULL) {

free(tmp->pointer)

}

free(tmp)

}

}

void __pool_alloc_memset(void* p, size_t len) {

size_t i

for (i = 0i <leni++) {

*((char*)(p+i)) = '\0'

}

}

MemPool* __pool_bottom(const MemPool* p) {

MemPool* tmp = (MemPool*)p

if (p == NULL) return NULL

while (tmp != NULL) {

if (tmp->next == NULL) {

break

} else {

tmp = tmp->next

}

}

return tmp

}

void __pool_for_each(MemPool* pool, FUNC_POOL_EACH func) {

MemPool *now = pool, *tmp

while(now != NULL) {

tmp = now

now = now->next

(*func)(tmp)

}

}

void* alloc_pool(MemPool* p, size_t l) {

MemPool *tmp = __pool_bottom(p), *pnew

if (tmp == NULL) return NULL

pnew = malloc(sizeof(MemPool))

if (pnew == NULL) return NULL

pnew->next = NULL

pnew->pointer = malloc(l)

__pool_alloc_memset(pnew->pointer, l)

tmp->next = pnew

return pnew->pointer

}

void delloc_pool(MemPool* pool, void * p) {

MemPool *now = pool, *parent

if (p == NULL) {

return

}

for(parent = nownow != NULLparent=now, now = now->next) {

if (p == now->pointer) {

parent->next = now->next

free(now->pointer)

free(now)

}

}

}

---