c#中指针的使用

最新推荐文章于 2022-01-09 14:44:53 发布
最新推荐文章于 2022-01-09 14:44:53 发布
阅读量250 收藏
点赞数
分类专栏： C# C shape 文章标签： c# byte image module class 语言

使用心得１：
ｃ＃中可以使用指针数组代替ｃ语言中的二维数组。
使用心得２：
ｃ＃中的指针生命周期仅限于为指针赋值的函数体，当函数返回时，指针的行为是不可预料的。
具体代码为：
using System;
using System.Collections.Generic;
using System.Text;
using System.Drawing.Imaging;
using System.Drawing;
using System.Runtime.InteropServices;

namespace sand.shilin.ModuleMatching
{
    public unsafe class ModuleMatchingFaster
    {

        public ModuleMatchingFaster()
        {
         
        }


        public unsafe static int[] MatchingFast()
        {
            int[] MatchedLocation = new int[2];
            Bitmap s = global::sand.shilin.ModuleMatching.Properties.Resources.lena2562;
            byte*[] S = new byte*[s.Height];
            for (int i = 0; i < s.Height; i++)
            {
                byte* pt = stackalloc byte[s.Width];
                S[i] = pt;
            }

            Image2Ptr(S, s);
            int sums = sum(s, S);


            s = global::sand.shilin.ModuleMatching.Properties.Resources.lenaT;
            byte*[] T = new byte*[s.Height];
            for (int i = 0; i < s.Height; i++)
            {
                byte* pt = stackalloc byte[s.Width];
                T[i] = pt;
            }

            Image2Ptr(T, s);
            int sumT = sum(s, T);


            int f = Convert.ToInt32(sumT * 0.1);
            int sumWeldingH = sums;
            int sumWelding = sums;
            int avrSource = sums / (35 * 44);
            int avrModule = sumT / (35 * 44);

            int*[] D = new int*[221];
            for (int i = 0; i < 212; i++)
            {
                int* pt = stackalloc int[221];
                D[i] = pt;
            }

            for (int i = 0; i < 212; i++)
            {
                for (int j = 0; j < 221; j++)
                {
                    int wucha = 0;
                    bool breaks = false;
                    int k = 0;
                    while (breaks == false && k < 44)
                    {
                        for (int l = 0; l < 35; l+=1)
                        {
                            wucha += Math.Abs(*(S[k + i] + l + j) - avrSource - *(T[k] + l) + avrModule);
                            if (wucha >= f)
                            {
                                breaks = true;
                                break;
                            }
                        }
                        k += 1;
                    }
                    int hang = 0;
                    for (int m = 0; m < 44; m++)
                    {
                        hang = hang - *(S[i + m] + j) + *(S[i + m] + j + 35 - 1);
                    }
                    sumWelding = sumWelding + hang;
                    avrSource = sumWelding / (35 * 44);
                    if (wucha < f)
                    {
                        f = wucha;
                    }
                    *(D[i] + j) = wucha;
                }
                int lie = 0;
                for (int n = 0; n < 35; n++)
                {
                    lie += *(S[i + 35 - 1] + n) - *(S[i] + n);
                }
                sumWeldingH = sumWeldingH + lie;
                sumWelding = sumWeldingH;
                avrSource = sumWeldingH / (35 * 44);
            }
            int min = *(D[0]);
            int p1 = 0;
            int p2 = 0;
            for (int i = 0; i < 212; i++)
            {
                for (int j = 0; j < 221; j++)
                {
                    if (*(D[i] + j) < min)
                    {
                        min = *(D[i] + j);
                        p1 = i;
                        p2 = j;
                    }
                }
            }
            int mmmm = min;
            MatchedLocation[0] = p1;
            MatchedLocation[1] = p2;
            return MatchedLocation;

        }

        unsafe private static void Image2Ptr(byte*[] S, Bitmap s)
        {

            BitmapData sData = s.LockBits(new Rectangle(0, 0, s.Width, s.Height),
            ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);
            int sstride = sData.Stride;
            System.IntPtr sScan0 = sData.Scan0;
            int sOffset = sstride - s.Width * 3;

            byte* sp = (byte*)(void*)sScan0;

            for (int i = 0; i < s.Height; i++)
            {
                for (int j = 0; j < s.Width; j++)
                {
                    *(S[i] + j) = sp[0];
                    sp += 3;
                }
                sp += sOffset;
            }
            s.UnlockBits(sData);
        }

        unsafe private static int sum(Bitmap s, byte*[] S)
        {
            int sum = 0;
            for (int i = 0; i < 44; i++)
            {
                for (int j = 0; j < 35; j++)
                {
                    sum += *(S[i] + j);
                }
            }
            return sum;
        }

   
    }
}
这是一个成功的代码。
以下是一个不成功的代码。
using System;
using System.Collections.Generic;
using System.Text;
using System.Drawing;
using System.Drawing.Imaging;
using System.Runtime.InteropServices;

namespace sand.shilin.ModuleMatching
{
    [Obsolete]
    unsafe public class ModuleMatching
    {
        Bitmap s = global::sand.shilin.ModuleMatching.Properties.Resources.lena2562;
        Bitmap t = global::sand.shilin.ModuleMatching.Properties.Resources.lenaT;
        byte*[] ptrSource;
        byte*[] ptrModule;

        public ModuleMatching()
        {
            ptrModule = new byte*[t.Height];
            for (int i = 0; i < t.Height; i++)
            {
                byte* pt = stackalloc byte[t.Width];
                ptrModule[i] = pt;
            }

            ptrSource = new byte*[s.Height];
            for (int i = 0; i < s.Height; i++)
            {
                byte* pt = stackalloc byte[s.Width];
                ptrSource[i] = pt;
            }
            CreatePtr(t, ptrModule);
            //int[,] MODULE = new int[44, 35];
            //for (int i = 0; i < 44; i++)
            //    for (int j = 0; j < 35; j++)
            //        MODULE[i, j] = *(ptrModule[i] + j);
        }
        unsafe public int[] MatchingFast()
        {
            int[] MatchedLocation = new int[2];
            CreatePtr(s, ptrSource);
            int sums = sum(ptrSource);

            int sumT = sum(ptrModule);


            int f = Convert.ToInt32(sumT);
            int sumWeldingH = sums;
            int sumWelding = sums;
            int avrSource = sums / (t.Width * t.Height);
            int avrModule = sumT / (t.Width * t.Height);

            int*[] D = new int*[s.Height - t.Height];
            for (int i = 0; i < s.Height - t.Height; i++)
            {
                int* pt = stackalloc int[s.Height - t.Height];
                D[i] = pt;
            }

            for (int i = 0; i < s.Height - t.Height; i++)
            {
                for (int j = 0; j < s.Width - t.Width; j++)
                {
                    int wucha = 0;
                    bool breaks = false;
                    int k = 0;
                    while (breaks == false && k < t.Height)
                    {
                        for (int l = 0; l < t.Width; l += 1)
                        {
                            wucha += Math.Abs(*(ptrSource[k + i] + l + j) - avrSource - *(ptrModule[k] + l) + avrModule);
                            if (wucha >= f)
                            {
                                breaks = true;
                                break;
                            }
                        }
                        k += 1;
                    }
                    int hang = 0;
                    for (int m = 0; m < t.Height; m++)
                    {
                        hang = hang - *(ptrSource[i + m] + j) + *(ptrSource[i + m] + j + t.Width - 1);
                    }
                    sumWelding = sumWelding + hang;
                    avrSource = sumWelding / (t.Width * t.Height);
                    if (wucha < f)
                    {
                        f = wucha;
                    }
                    *(D[i] + j) = wucha;
                }
                int lie = 0;
                for (int n = 0; n < t.Width; n++)
                {
                    lie += *(ptrSource[i + t.Width - 1] + n) - *(ptrSource[i] + n);
                }
                sumWeldingH = sumWeldingH + lie;
                sumWelding = sumWeldingH;
                avrSource = sumWeldingH / (t.Width * t.Height);
            }
            int min = *(D[0]);
            int p1 = 0;
            int p2 = 0;
            for (int i = 0; i < s.Height - t.Height; i++)
            {
                for (int j = 0; j < s.Width - t.Width; j++)
                {
                    if (*(D[i] + j) < min)
                    {
                        min = *(D[i] + j);
                        p1 = i;
                        p2 = j;
                    }
                }
            }
            int mmmm = min;
            MatchedLocation[0] = p1;
            MatchedLocation[1] = p2;
            return MatchedLocation;

        }

        unsafe private void CreatePtr(Bitmap s, byte*[] p)
        {
            BitmapData sData = s.LockBits(new Rectangle(0, 0, s.Width, s.Height),
            ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb);
            int sstride = sData.Stride;
            System.IntPtr sScan0 = sData.Scan0;
            int sOffset = sstride - s.Width * 3;

            byte* sp = (byte*)(void*)sScan0;

            for (int i = 0; i < s.Height; i++)
            {
                for (int j = 0; j < s.Width; j++)
                {
                    *(p[i] + j) = sp[0];
                    sp += 3;
                }
                sp += sOffset;
            }
            s.UnlockBits(sData);
        }

 

        unsafe private int sum(byte*[] p)
        {
            int sum = 0;
            for (int i = 0; i < t.Height; i++)
            {
                for (int j = 0; j < t.Width; j++)
                {
                    sum += *(p[i] + j);
                }
            }
            return sum;
        }

    }
}
在构造函数返回后，ptrModule的值变得不可预料，在MatchingFast中，ptrModule已经变得不可用。

eattonton
关注
专栏目录
C#中的指针是什么
qq_39605374的博客
10-14 214
尽管指针在某些特定情况下可能很有用，但在大多数情况下，C#的引用类型和值类型已经足够满足开发人员的需求。C#的引用类型使用引用语义，而不需要使用指针来直接操作内存。因此，在一般情况下，我们应该避免使用指针，以确保代码的安全性和可读性。在C#中，指针的使用是受到限制的，并且需要显式地启用指针功能。因此，在C#中使用指针时必须格外小心，并确保只在必要的情况下使用指针。然而，在实际开发中，应该谨慎使用指针，并确保只在必要的情况下使用它们。总结起来，C#中的指针是一种特殊的数据类型，用于存储和操作内存中的数据。
.NET(C#) 中使用指针
weixin_42098295的博客
01-24 1477
在 .NET 中，C# 默认情况下是一种安全的、不支持直接使用指针的语言。然而，C# 支持在特定情况下使用不安全代码（即可以使用指针的代码）。使用不安全代码意味着放弃了 C# 和 .NET 运行时提供的一些安全保障，因此必须谨慎使用。不安全代码可能会增加程序出错的风险，特别是与内存管理相关的错误，如堆损坏、内存泄漏等。指针操作通常只在性能至关重要的情况下使用，或者在需要与系统级别或非托管代码互操作时使用。
C#使用指针
weixin_33676492的博客
10-13 139
很多人将C#和Java进行比较的时候，认为C#支持指针是C#的一个特点。我的个人观点认为任何事务应该一分为二的看，有利必然有弊。关于支持指针是好还是不好，不同的人有不同的看法，这个讨论很多。我们在此仅仅是讨论如何在C#中使用指针，并不是讨论它的利弊。 1、修改工程配置工程中默认的配置是不支持代码的非安全性的，如果我们想使用指针就要修改这个默认的设置。否则我们在编译的时候就会出现“不安全代码只会在...
C#中指针的使用（转）
weixin_34007020的博客
03-04 467
在C#中，有时候希望通过指针来操作内存，这样可以提高效率。我们可以用unsafe关键字修饰含有指针操作的程序段，如下所示： class Program{ static int Main(string[] args) { unsafe { // ... } }} unsafe只是编译器指令语法，只是在编译的时候起作...
在c#中使用指针
木东的博客
06-21 6471
如果想在c#中使用指针，首先对项目进行配置：在解决方案资源管理器中右击项目名选择属性（或在项目菜单中选择consoleApplication属性(consoleApplication为项名)），在生成选项卡中 选中“允许不安全代码”，如下图：       然后将有关指针，地址的操作放在unsafe语句块中。使用unsafe关键字是来告诉编译器下面的代码是不安全的。 unsafe
指针总结（1）
Chakra_Z06的博客
06-28 138
一级指针 #define _CRT_SECURE_NO_WARNINGS 1 #include <stdio.h> int main() { int a = 10; //在内存中开辟一块空间 int *p = &a;//这里我们对变量a，取出它的地址，可以使用&操作符。 //将a的地址存放在p变量中，p就...
C# csharp指针 案例
04-24
void*类型的指针可以指向任何类型，但在C#中通常不推荐使用，因为它缺乏类型安全。T*类型的指针是类型安全的，它只能指向特定类型的数据。而固定缓冲区则是在结构体中定义的一段连续内存，常用于处理数组或原始数据...
C#中的指针和内存管理以及垃圾回收PPT
最新发布
03-28
在C#编程语言中，虽然直接操作指针的情况较为少见，但确实存在某些应用场景下需要使用到指针。C#设计初衷是为了提供一种更加安全且易于管理内存的方法，但这并不意味着完全禁止使用指针。在某些特定情况下，如需要与...
C#结构体指针的定义及使用详解
03-04
通过上述讲解，我们可以了解到在C#中如何定义和使用结构体指针。这对于需要与非托管代码交互或直接操作内存的场景非常有用。不过需要注意的是，使用指针时一定要小心，避免出现未定义行为或安全问题。在实际开发中，...
C#中this指针的用法示例
01-20
当你在一个类的方法或属性中使用`this`时，它指向的就是调用该方法或属性的那个对象。类是对现实世界中事物的抽象，而对象则是类的具体实例。当你创建一个类的实例，比如`Person person = new Person();`，`person`...
C# 指针
liuerquan的专栏
03-12 236
运算符/语句 使用   * 执行指针间接寻址。   -&gt; 通过指针访问结构的成员。   [] 为指针建立索引。   &amp; 获取变量的地址。   ++ 和 -- 递增和递减指针。   + 和 - 执行指针算法。   ==、!=、&lt;、&gt;、 &lt;= 和 &gt;= 比较指针。   stackalloc 在堆栈上分配内存。   fixed ...
C#指针
程序媛的梦想
07-24 2059
指针在C\\C++里面可是一个好东西，但是到Java，.Net的时代指针已经被封装起来，对用户不可见，这点Java做的非常的彻底。.Net可能因为还存在一个托管C＋＋，因此指针并没有完全废除，C＃还是保留了指针的操作。               要使用指针首先要对使用指针的代码用unsafe进行进行声明，声明和public声明一样，可以对整个类进行声明，也可以是类里面某个方法或者属性。在代码里
c#中的指针
Bernie6的博客
09-04 1727
指针是非强类型化的，当使用一个指针的时候，指向的不是一个特定的类型，而仅仅是一块内存区。对这个指针进行位移操作，然后向此位置写入，就可能破坏内存，因此称可以直接操作内存的代码为不安全的（unsafe）。 平时我们使用C#，是在托管平台上，这个平台之所以被称为“托管的”，是因为编程人员不再需要为内存的分配、管理和回收做太多的工作，CLR会在内部管理程序的内存。 但是在某些特殊的情况下，如与本地代码或...
C#里的指针
weixin_30919919的博客
07-13 228
最近在复习C#基础这里，发现指针运算方式跟引用类型运算方式很相像。 指针里面存放的是表示内存地址的一段整数，所以任何整数类型指针之间都可以相互转换，因此带来了不安全性。 long longint = 12; long* b = &longint; uint* c = (...
[C#] C#中的指针
热门推荐
unity尧明的博客
01-09 2万+
  C#在有限的范围内支持指针。C#的指针只不过是一个持有另一类型内存地址的变量。但是在C#中，指针只能被声明为持有值类型和数组的内存地址。与引用类型不同，指针类型不被默认的垃圾收集机制所跟踪。出于同样的原因，指针不允许指向引用类型，甚至不允许指向包含引用类型的结构类型。我们可以说，指针只能指向非托管类型，包括所有基本数据类型、枚举类型、其他指针类型和只包含非托管类型的结构。 声明指针类型 声明指针类型的一般形式如下所示， type *variable_name; 其中 * 称为取消引用运算符。例如下面的语
C#中指针
似水流年
04-05 1060
指针是一个无符号整数，它是一个以当前系统寻址范围为取值范围的整数，CLR支持3种指针类型：受托管指针，非托管指针和非托管函数指针。受托管指针存储在堆上的托管快的引用，非托管指针也就是指传统意义上的指针，在C#中必须要放在unsafe代码块中使用指针。       & 寻址运算符，它表示取地址，并把一个值数据类型转换为指针。       *  间接寻址运算符 它表示获取地址的内容，把一个指针转换
C# 指针操作
灰太狼的小秘密
11-02 3757
以下总结C#指针操作的知识点 一、unsafe的用法 1、C#使用指针首先要用unsafe声明 unsafe声明可以用在方法或代码块 （1）方法声明为unsafe static unsafe void Main(string[] args) { int var = 20; int* p = &var...
C#中使用指针
gubaofu的博客
11-26 156
首先在工程属性中设置允许不安全的代码： 然后在使用指针的地方加上unsafe修饰符 unsafe { //使用指针的代码 } // 或者 unsafe int FunName(int x,int y); 最后如果需要固定某些变量，那么要加上fixed fixed (int* p = var) { //code } ...
C#中指针的使用详解
"本文主要探讨了如何在C#中使用指针，并强调了尽管C#不推荐使用指针，但在FCL（框架类库）中，指针的重要性不容忽视，特别是在处理如String、Encoding、FileStream等类时。文章通过示例代码展示了在C#中使用`fixed`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值