char* 类型数组 可以用NULL来判断是否结束
那么int* 型数组 如何判断是否结束呢

int f_find(int *s,int f)
{
    int ret=0;
    while(*s!=NULL)    //这个语句不能用啊
    {
        if(*s==f) ret++;
        *s++;
    }
    return ret;
}

#include <stdio.h>

typedef int Type;
//typedef double Type; 修改这里

#define VALUE Type
#define ITER  Type*

ITER f_find(ITER begin, ITER end, VALUE val)
{
    while(begin != end)
    {
        if( *begin == val) return begin;
        ++begin;
    }
    return end;
}

int main()
{
    int s[]    = {1, 2, 3, 4};
    //double s[] = {1.1f, 1.2f, 1.3f, 1.4f}; 修改这里

    ITER s_begin = s;
    ITER s_end   = s + sizeof(s) / sizeof(s[0]);

    ITER result = f_find(s_begin, s_end, 3);
    //ITER result = f_find(s_begin, s_end, 1.3f); 修改这里

    if(result != s_end ) 
        printf("找到了该值 %d\n", *result);
        //printf("找到了该值 %.2f\n", *result); 修改这里
    else 
        printf("没有找到该值\n");

    return 0;
}

一串好玩的代码, 运行后,你可以试着把每个注释行上面的那行注释掉, 然后把注释行打开, 再编译运行.
这个是迭代器的思想.不知道你学Delphi里面有没有学到过这个.

谢谢  收了

int main(void)
{
   int t[5];
   int *p;
   p=&t[0];
   for(int i=0;i<5;i++)
   {
       *p=i+10;
       printf("*p=%d  t[]=%d\n",*p,t[i]);
       p++;
   }
   return 0;
}

你可以在理解指针的基础上看这个, ITER 本身就是英文:iterator 迭代器的缩写, 迭代器本身就是指针的原理.
f_find 在这里的作用就是泛型算法:查找值的泛型写法.
有两个问题留给你: 1.s_begin 指向哪里? 2.s_end 又指向哪里? 为什么s_end可以指向那里?

[ 本帖最后由 newdos 于 2012-11-30 13:56 编辑 ]

#include <stdio.h>

typedef int Type;
#define VALUE Type
#define ITER  Type*

ITER f_find(ITER begin, ITER end, VALUE val)
{
    while(begin != end)
    {
        if( *begin == val) return begin;
        ++end;
    }
    return begin;
}

int main()
{
    int s[]    = {1, 3, 3, 4, 3, 3, 3};
    int *p=&s[0];
    p++;   //从数组第2位向后找
    ITER s_begin = p;
    ITER s_end   = p + sizeof(p) / sizeof(p[0]);
    ITER result = f_find(s_begin, s_end, 3);
    printf("共找到了%d 个 %d\n", *result,3);
    //期待打印结果是 共找到了5个3
    return 0;
}

这个应该怎么修改呢

哦 抱歉，刚刚没看到这个

这个我无法立马回复   我会慢慢边搜索边研究的  谢谢

你可以再依样写一个count计算出现个数的算法

#include <stdio.h>

typedef int Type;
//typedef double Type;

#define VALUE Type
#define ITER  Type*

ITER f_find(ITER begin, ITER end, VALUE val)
{
    while(begin != end)
    {
        if( *begin == val) return begin;
        ++begin;
    }
    return end;
}

// 泛型count计数算法
int f_count(ITER begin, ITER end, VALUE val)
{
    int count = 0;
    while(begin != end)
    {
        if( *begin == val) ++count;
        ++begin;
    }
    return count;

}

int main()
{
    int s[]    = {1, 3, 3, 4, 3, 3, 3};
    int *p=&s[0];
    p++;   //从数组第2位向后找
    ITER s_begin = s;
    ITER s_end   = s + sizeof(s) / sizeof(s[0]);
    //ITER result = f_find(s_begin, s_end, 3);
    int result = f_count(s_begin, s_end, 3);

    printf("共找到了%d 个 %d\n", result,3);
    //期待打印结果是 共找到了5个3
    return 0;
}

慢慢来吧,这个是指针的另一个有趣的例子,如果你也能理解的话,你会发现指针在编程中其实无处不在.
C中还有函数型指针void (* pf)(int x, int y); 可以实现更精彩的东西.
数据结构中,你也会发现指针在里面的应用.

#include <stdio.h>

typedef int Type;
#define VALUE Type
#define ITER  Type*

// 泛型count计数算法
int f_count(ITER begin, ITER end, VALUE val)
{
    int count = 0;
    while(begin != end)  //这里end=10044  begin=10000
    {
        //printf("begin=%x,end=%x\n",begin,end); //经过这句代码验证了下面的猜测
        if( *begin == val) ++count;
        ++begin;   //这里begin步长为4
    }
    return count;

}

int main()
{
    int s[]    = {1, 3, 3, 4, 3, 3, 3, 5, 4, 3, 3};
    int *p=&s[0];
    p++;
    p++;//从数组第3位向后找
    ITER s_begin = p;  //这里假定s_begin=p=10000
    ITER s_end   = p + sizeof(s) / sizeof(s[0]);  //这里s_end=10000+数组元素长11*4=10044
    /*
      感觉这里s_end越界了 p是第3个元素,p+11就是第14个元素了，所以我用了一句
      ITER s_end   = p + sizeof(s) / sizeof(s[0])-8; 向前串2个单元，好了
      有5个3被吃掉了，不理解呢
    */
    int result = f_count(s_begin, s_end, 3);
    printf("共找到了%d 个 %d\n", result,3);
    return 0;
} 

[ 本帖最后由 wp231957 于 2012-11-30 15:18 编辑 ]