c語言釋放資源

1. c語言包含一個exe文件到資源 並且把釋放到C:\ 求代碼

在RC文件中將EXE文件當作「BINDATA」插入；
使用LoadResource()獲得其句柄；
使用LockResource()獲得其二進制數據指針；
使用CreateFile()和WriteFile()創建和寫入文件

2. C語言編程時使用MALLOC後未用FREE函數釋放內存空間怎麼辦

1 malloc後的內存除了等到free來釋放，還可以等到程序運行結束時自動釋放
2 程序運行過程中，如果一直malloc內存而不釋放會導致這部分內存不能被再次使用，即內存泄露。這樣以來，應用程序會逐漸用光所有可用的內存，最終導致應用程序因內存不足而崩潰停止。
3 所以一個好的習慣是，malloc後一定要記得free之。

3. c語言中靜態變數需要自己釋放那外部變數屬於靜態存儲方式，書上說靜態變數的生存期是整個程序的運行期

對，一個運行的程序屬於一個進程，進程是由操作系統管理的，程序結束了，該程序所佔用的資源會由操作系統來回收。

靜態變數的靜態：變數佔用的存地址不釋放，也就是說它的地址它從頭到尾一內直占著，容不給其他內存單元佔用而已，其本身的值是可以改變的。

動態的變數：比如調用函數體里定義的變數，在函數執行後便釋放出去，把有用的地址資源貢獻給其他量，釋放以後如果你用指針來列印這個地址的值的話，就很有可能不是原來的值了。

(3)c語言釋放資源擴展閱讀：

靜態變數也可以用於存儲常數。具體來說，靜態變數（全局變數及匯編語言里定義的符號亦同）可用const，constant或final（根據語言決定）等關鍵字標識，這時其值就會在編譯時設定，並且無法在運行時改變。

編譯器通常將靜態常量與文本一起置於目標文件的文本區域，而非常量初始化數據則置於數據區；而如若有需要，有些編譯器還可選擇為其開辟專用區；為防止常數變數被錯誤的指針寫入覆蓋，亦可在這塊區域啟用內存保護機制。

4. C語言中是如何釋放內存單元的；原理又是什麼

C管理內存大致可以理解為兩種，分配在棧上的，一個是分配在堆上的。

臨時變數，動態變數，分配在棧上，運行完，直接彈出棧，就沒了。
分配在堆上的內存，釋放的時候，基本上可以理解為，指針不指這里了。也就失去了對這塊內存的控制。其實所謂的釋放。字面意思容易讓人理解錯。
有些機器有些操作系統，會在釋放的時候清空這段內存，但是這種做法效率不高，但是安全，很少有機器這么做，多數都是所謂釋放，就是不讓你控制這塊內存了而已。

5. 在C語言進行編程中，為什麼要釋放舊內存

我們老師說的是C++ 沒有回收動態申請內存的機制。需要主動釋放。JAVA等高級語言有這種機制。剛查了下貌似C++確實沒有。
即是說C/C++ 都需要主動釋放動態申請的內存。

試著解釋下為什麼要主動釋放動態申請的內存：
1.動態申請的內存，存儲在堆中，編譯器不會自己回收，回收的意義：通俗講就是告訴編譯器，這片內存可以使用。
如果不被回收，這片內存就永遠都不會被重新利用。也就是內存泄露。
例如 int *a=(int *)malloc (sizeof(int)*4);
2.現在只有a這個指針指向這片動態申請的內存，再沒有別的路徑可以找到這片內存空間了。如果在釋放a所指向的內存空間之前就改變了a的指向，那麼可知，這片內存，將不可能再被找到了。那麼這片內存就不會被釋放，也就是上面說到的內存泄露。

6. c語言中,程序結束時,動態內存會釋放嗎是由誰釋放的

1 從C語言本身設計來說，不會釋放。
所謂動態內存，是由malloc系列函數進行申請的內存，除非在程序中使用free釋放，否則該段內存不會被釋放掉。
從這個角度來說，即使進程結束，該段內存也會被佔用。這種現象被稱為內存泄露。
2 大多數操作系統可以智能釋放。
動態內存由於是進程使用，向操作系統控制方申請的內存，所以操作系統內核可以記錄哪些內存由哪個進程使用，這樣為了減少內存泄露的危害，操作系統內核均實現了在進程退出後，進程分配的自用內存自動回收的機制。
3 仍要避免在書寫只分配不釋放的代碼。
作為代碼編寫者，要遵從C語言要求的自行釋放不用內存的規則，使程序盡量少佔用資源。否則是對內存資源的浪費。

7. C語言菜鳥求助：關於C語言中變數釋放的問題

變數釋放就是告訴系統你不用這塊地址了，別的程序可以對那塊地址進行賦值等操作，因此那塊地址的值你就不可控了，即使你再對它賦值，也可能被別的程序改變，產生意想不到的結果。

8. C#.net如何手動釋放內存資源

C#中對象的銷毀有三種方式Finalize，Dispose，GC
1 public class Foo: IDisposable
2 {
3 public void Dispose()
4 {
5 Dispose(true);
6 GC.SuppressFinalize(this);
7 }
8
9 protected virtual void Dispose(bool disposing)
10 {
11 if (!m_disposed)
12 {
13 if (disposing)
14 {
15 // Release managed resources
16 }
17
18 // Release unmanaged resources
19
20 m_disposed = true;
21 }
22 }
23
24 ~Foo()
25 {
26 Dispose(false);
27 }
28
29 private bool m_disposed;
30 }
31

在.NET的對象中實際上有兩個用於釋放資源的函數：Dispose和Finalize。Finalize的目的是用於釋放非託管的資源，而Dispose是用於釋放所有資源，包括託管的和非託管的。

在這個模式中，void Dispose(bool disposing)函數通過一個disposing參數來區別當前是否是被Dispose()調用。如果是被Dispose()調用，那麼需要同時釋放 託管和非託管的資源。如果是被~Foo()（也就是C#的Finalize()）調用了，那麼只需要釋放非託管的資源即可。

這是因為，Dispose()函數是被其它代碼顯式調用並要求釋放資源的，而Finalize是被GC調用的。在GC調用的時候Foo所引用的其它 託管對象可能還不需要被銷毀，並且即使要銷毀，也會由GC來調用。因此在Finalize中只需要釋放非託管資源即可。另外一方面，由於在 Dispose()中已經釋放了託管和非託管的資源，因此在對象被GC回收時再次調用Finalize是沒有必要的，所以在Dispose()中調用 GC.SuppressFinalize(this)避免重復調用Finalize。

然而，即使重復調用Finalize和Dispose也是不存在問題的，因為有變數m_disposed的存在，資源只會被釋放一次，多餘的調用會被忽略過去。

因此，上面的模式保證了：

1、 Finalize只釋放非託管資源；

2、 Dispose釋放託管和非託管資源；

3、 重復調用Finalize和Dispose是沒有問題的；

4、 Finalize和Dispose共享相同的資源釋放策略，因此他們之間也是沒有沖突的。

在C#中，這個模式需要顯式地實現，其中C#的~Foo()函數代表了Finalize()。而在C++/CLI中，這個模式是自動實現的，C++的類析構函數則是不一樣的。

按照C++語義，析構函數在超出作用域，或者delete的時候被調用。在Managed C++（即.NET 1.1中的託管C++）中，析構函數相當於CLR中的Finalize()方法，在垃圾收集的時候由GC調用，因此，調用的時機是不明確的。在.NET 2.0的C++/CLI中，析構函數的語義被修改為等價與Dispose()方法，這就隱含了兩件事情：

1、 所有的C++/CLI中的CLR類都實現了介面IDisposable，因此在C#中可以用using關鍵字來訪問這個類的實例。

2、 析構函數不再等價於Finalize()了。

對於第一點，這是一件好事，我認為在語義上Dispose()更加接近於C++析構函數。對於第二點，Microsoft進行了一次擴展，做法是引入了「！」函數，如下所示：

1 public ref class Foo
2 {
3 public:
4 Foo();
5 ~Foo(); // destructor
6 !Foo(); // finalizer
7 };
8

「！」函數（我實在不知道應該怎麼稱呼它）取代原來Managed C++中的Finalize()被GC調用。MSDN建議，為了減少代碼的重復，可以寫這樣的代碼：

1 ~Foo()
2 {
3 //釋放託管的資源
4 this->!Foo();
5 }
6
7 !Foo()
8 {
9 //釋放非託管的資源
10 }
11

對於上面這個類，實際上C++/CLI生成對應的C#代碼是這樣的：

1 public class Foo

2 {
3 private void !Foo()
4 {
5 // 釋放非託管的資源
6 }
7
8 private void ~Foo()
9 {
10 // 釋放託管的資源
11 !Foo();
12 }
13
14 public Foo()
15 {
16 }
17
18 public void Dispose()
19 {
20 Dispose(true);
21 GC.SuppressFinalize(this);
22 }
23
24 protected virtual void Dispose(bool disposing)
25 {
26 if (disposing)
27 {
28 ~Foo();
29 }
30 else
31 {
32 try
33 {
34 !Foo();
35 }
36 finally
37 {
38 base.Finalize();
39 }
40 }
41 }
42
43 protected void Finalize()
44 {
45 Dispose(false);
46 }
47 }
48

由於~Foo()和!Foo()不會被重復調用（至少MS這樣認為），因此在這段代碼中沒有和前面m_disposed相同的變數，但是基本的結構是一樣的。

並且，可以看到實際上並不是~Foo()和!Foo()就是Dispose和Finalize，而是C++/CLI編譯器生成了兩個Dispose 和Finalize函數，並在合適的時候調用它們。C++/CLI其實已經做了很多工作，但是唯一的一個問題就是依賴於用戶在~Foo()中調 用!Foo()。

關於資源釋放，最後一點需要提的是Close函數。在語義上它和Dispose很類似，按照MSDN的說法，提供這個函數是為了讓用戶感覺舒服一點，因為對於某些對象，例如文件，用戶更加習慣調用Close()。

然而，畢竟這兩個函數做的是同一件事情，因此MSDN建議的代碼就是：

1 public void Close()

2 {
3 Dispose(();
4 }
5
6
這里直接調用不帶參數的Dispose函數以獲 得和Dispose相同的語義。這樣似乎就圓滿了，但是從另外一方面說，如果同時提供了Dispose和Close，會給用戶帶來一些困惑。沒有看到代碼 細節的前提下，很難知道這兩個函數到底有什麼區別。因此在.NET的代碼設計規范中說，這兩個函數實際上只能讓用戶用一個。因此建議的模式是：

1 public class Foo: IDisposable
2 {
3 public void Close()
4 {
5 Dispose();
6 }
7
8 void IDisposable.Dispose()
9 {
10 Dispose(true);
11 GC.SuppressFinalize(this);
12 }
13
14 protected virtual void Dispose(bool disposing)
15 {
16 // 同前
17 }
18 }
19

這里使用了一個所謂的介面顯式實現：void IDisposable.Dispose()。這個顯式實現只能通過介面來訪問，但是不能通過實現類來訪問。因此：

1 Foo foo = new Foo();

2
3 foo.Dispose(); // 錯誤
4 (foo as IDisposable).Dispose(); // 正確
5

----------------------------------以下是CSDN上一位高手的總結----------------------------------------------

1、Finalize方法（C#中是析構函數，以下稱析構函數）是用於釋放非託管資源的，而託管資源會由GC自動回收。所以，我們也可以這樣來區分 託管和非託管資源。所有會由GC自動回收的資源，就是託管的資源，而不能由GC自動回收的資源，就是非託管資源。在我們的類中直接使用非託管資源的情況很 少，所以基本上不用我們寫析構函數。

2、大部分的非託管資源會給系統帶來很多負面影響，例如資料庫連接不被釋放就可能導致連接池中的可用資料庫連接用盡。文件不關閉會導致其它進程無法讀寫這個文件等等。

實現模型：
1、由於大多數的非託管資源都要求可以手動釋放，所以，我們應該專門為釋放非託管資源公開一個方法。實現IDispose介面的Dispose方法是最好的模型，因為C#支持using語句快，可以在離開語句塊時自動調用Dispose方法。

2、雖然可以手動釋放非託管資源，我們仍然要在析構函數中釋放非託管資源，這樣才是安全的應用程序。否則如果因為程序員的疏忽忘記了手動釋放非託管資源， 那麼就會帶來災難性的後果。所以說在析構函數中釋放非託管資源，是一種補救的措施，至少對於大多數類來說是如此。

3、由於析構函數的調用將導致GC對對象回收的效率降低，所以如果已經完成了析構函數該乾的事情（例如釋放非託管資源），就應當使用SuppressFinalize方法告訴GC不需要再執行某個對象的析構函數。

4、析構函數中只能釋放非託管資源而不能對任何託管的對象/資源進行操作。因為你無法預測析構函數的運行時機，所以，當析構函數被執行的時候，也許你進行操作的託管資源已經被釋放了。這樣將導致嚴重的後果。

5、（這是一個規則）如果一個類擁有一個實現了IDispose介面類型的成員，並創建（注意是創建，而不是接收，必須是由類自己創建）它的實例對象，則 這個類也應該實現IDispose介面，並在Dispose方法中調用所有實現了IDispose介面的成員的Dispose方法。
只有這樣的才能保證所有實現了IDispose介面的類的對象的Dispose方法能夠被調用到，確保可以手動釋放任何需要釋放的資源。分享給你的朋友吧：人人網新浪微博開心網MSNQQ空間
對我有幫助
8

9. c語言代碼 如何釋放資源

這就要看你的資源是new出來的還是 malloc分配的。
如果是new 出來的內存資源的話，那麼就用delete釋放，
如果是malloc分配出來的內存資源的話，那麼就用free()釋放。
例如：
char* c = new char[20]; //new 一個char類型內存的數組

char *ptr =(char*)malloc(sizeof(char)*20); //malloc分配20個char類型的內存

delete c; //釋放c的內存
free(ptr); //釋放ptr的內存