Merge pull request #6061 from carsonRadtke/carsonradtke/alloc-dealloc-mismatch-docs

[dev18] new docs for new alloc/dealloc mismatch warning

Author: JamesJBarnett

docs/code-quality/c26865.md

@@ -0,0 +1,54 @@
+---
+description: "Learn more about: Warning C26865"
+title: Warning C26865 
+ms.date: 10/03/2022
+f1_keywords: ["C26865", "ALLOCATION_DEALLOCATION_MISMATCH", "__WARNING_ALLOCATION_DEALLOCATION_MISMATCH"]
+helpviewer_keywords: ["C26865"]
+ms.assetid: 2fbe9dc5-fa43-47b9-97a7-3f8215da1d40
+---
+# Warning C26865
+
+> Memory allocated with '\<allocation-function\>' is being deallocated with '\<wrong-deallocation-function\>'. Use '\<correct-deallocation-function\>' instead.
+
+This rule was added in Visual Studio 2026 18.0.
+
+## Remarks
+
+This warning indicates that the memory was allocated with one family of allocation functions, but was freed with a deallocation function from a different family. This usage results in undefined behavior according to C/C++ and the Microsoft MSVC implementation.
+
+The exact ramifications of this defect are difficult to predict. It might result in leaks for classes with destructors that perform memory deallocation. It could cause inconsistent behavior for classes with destructors that perform semantically significant operations, or memory corruptions and crashes. In other cases the mismatch might be unimportant, depending on the implementation of the compiler and its libraries. Analysis tools can't always distinguish between these situations.
+
+If memory is allocated with one family of allocation functions, it should be freed with a matching deallocation function.
+
+C26865 covers the following allocation/deallocation pairs:
+
+- C++ scalar new (`new`) must be deallocated with scalar delete (`delete`).
+- C++ array new (`new[]`) must be deallocated with array delete (`delete[]`).
+- C/C++ `malloc`/`calloc`/`realloc` must be deallocated with `free` (or `realloc`).
+- Windows `HeapAlloc` must be deallocated with `HeapFree`.
+- Windows `GlobalAlloc` must be deallocated with `GlobalFree`.
+- Windows `LocalAlloc` must be deallocated with `LocalFree`.
+- Windows `MIDL_user_allocate` must be deallocated with `MIDL_user_free`.
+- Component Object Model (COM) `CoTaskMemAlloc` must be deallocated with `CoTaskMemFree`.
+
+Code analysis name: `ALLOCATION_DEALLOCATION_MISMATCH`
+
+## Example
+
+The following sample code generates warning C26865:
+
+```cpp
+void f() {
+    int *pInt = (int *)calloc(10, sizeof(int));
+    // code ...
+    delete pInt; // C26865: Memory allocated with 'calloc' is being deallocated with 'delete'. Use 'free' instead.
+}
+
+void g() {
+    char * str = new char[50];
+    // code ...
+    delete str; // C26865: Memory allocated with 'new[]' is being deallocated with 'delete'. Use 'delete[]' instead.
+}
+```
+
+Manual memory management has many pitfalls in terms of memory leaks and exceptions. To avoid these kinds of potential leaks altogether, use the mechanisms that are provided by the C++ Standard Library (STL). These mechanisms include [`shared_ptr`](../standard-library/shared-ptr-class.md), [`unique_ptr`](../standard-library/unique-ptr-class.md), and containers such as [`vector`](../standard-library/vector.md). For more information, see [Smart pointers](../cpp/smart-pointers-modern-cpp.md) and [C++ Standard Library](../standard-library/cpp-standard-library-reference.md).

docs/code-quality/c6278.md

@@ -9,6 +9,10 @@ helpviewer_keywords: ["C6278"]
 
 > '*variable*' is allocated with array new [], but deleted with scalar delete. Destructors will not be called.
 
+## Notice
+
+Warning C6278 was removed in Visual Studio 2026. Use the more generic warning [`C26865`](../code-quality/C26865.md) instead.
+
 ## Remarks
 
 This warning appears only in C++ code and indicates that the calling function has inconsistently allocated memory with the array **`new []`** operator, but freed it with the scalar **`delete`** operator. This usage is undefined behavior according to the C++ standard and the Microsoft C++ implementation.

docs/code-quality/c6279.md

@@ -9,6 +9,12 @@ helpviewer_keywords: ["C6279"]
 
 > '*variable-name*' is allocated with scalar new, deleted with array delete []
 
+This warning appears only in C++ code and indicates that the calling function has inconsistently allocated memory with the scalar `new` operator, but freed it with the array `delete[]` operator. If memory is allocated with scalar `new`, it should typically be freed with scalar `delete`.
+
+## Notice
+
+Warning C6279 was removed in Visual Studio 2026. Use the more generic warning [`C26865`](../code-quality/C26865.md) instead.
+
 ## Remarks
 
 This warning appears only in C++ code and indicates that the calling function has inconsistently allocated memory with the scalar `new` operator, but freed it with the array `delete[]` operator. If memory is allocated with scalar `new`, it should typically be freed with scalar `delete`.

docs/code-quality/c6280.md

@@ -9,6 +9,12 @@ helpviewer_keywords: ["C6280"]
 
 > '*variable-name*' is allocated with '*function-name-1*', but deleted with '*function-name-2*'
 
+This warning indicates that the calling function has inconsistently allocated memory by using a function from one family and freed it by using a function from another.
+
+## Notice
+
+Warning C6280 was removed in Visual Studio 2026. Use the more generic warning [`C26865`](../code-quality/C26865.md) instead.
+
 ## Remarks
 
 This warning indicates that the calling function has inconsistently allocated memory by using a function from one family and freed it by using a function from another.

docs/code-quality/c6283.md

@@ -9,6 +9,12 @@ helpviewer_keywords: ["C6283"]
 
 > '*variable-name*' is allocated with array new [], but deleted with scalar delete
 
+This warning appears only in C++ code and indicates that the calling function has inconsistently allocated memory with the array `new []` operator, but freed it with the scalar `delete` operator.
+
+## Notice
+
+Warning C6283 was removed in Visual Studio 2026. Use the more generic warning [`C26865`](../code-quality/C26865.md) instead.
+
 ## Remarks
 
 This warning appears only in C++ code and indicates that the calling function has inconsistently allocated memory with the array `new []` operator, but freed it with the scalar `delete` operator.

docs/code-quality/toc.yml

@@ -661,6 +661,8 @@ items:
     href: ../code-quality/c26863.md
   - name: Warning C26864
     href: ../code-quality/c26864.md
+  - name: Warning C26865
+    href: ../code-quality/c26865.md
   - name: Warning C28020
     href: ../code-quality/c28020.md
   - name: Warning C28021