Question

关于C++指针的问题

//计算并输出前10个素数
#include <iostream>
#include <iomanip>
using namespace std;
#define MAX 10
void main()
{
int i,j,n,p,r,primes[MAX];
int *pw,*pr;//为什么要定义这两个指针？这两个指针在下面程序中都指向了数组首地址 那么干脆就把所有pw,pr都替换成数组首地址不就行了？可是替换后又不能得出结果。为什么？
long q;
pw=primes;//为什么把数组的首地址赋给了PW？
n=2;
*pw++=2;*pw++=3;//为什么pw的值同时赋给了两个整数？
i=5;
do
{
pr=primes;//为什么把数组的首地址赋给了PR？
do
{
p=*pr++;
q=i/p;
r=i-q*p;
} while (r&&i<q*q);
if (r)
{
*pw++=i;
n++;
}
i+=2;
} while (n<MAX);
j=0;
pr=primes;//为什么再次把数组的首地址赋给了PR？
for (i=0;i<MAX;++i)
{
cout<<*pr++<<setw(3);
if (++j==10)
{
cout<<endl;
j=0;
}
}
}
最好能翻译整个程序 如果翻译得好 可以加分

Answer 1

程序的功能
__________________________________________________________________
形成一个十元素数组，数组内的元素不能被其它元素整除。(说白了就是求前十个素数)
__________________________________________________________________
#define MAX 10
void main()
{
int i,j,n,p,r,primes[MAX]; //定义i,j,n,p,r,primes数组 为整型。。
int *pw,*pr;//(答案见A)为什么要定义这两个指针？这两个指针在下面程序中都指向了数组首地址 那么干脆就把所有pw,pr都替换成数组首地址不就行了？可是替换后又不能得出结果。为什么？
long q;再定义一个长整型q
pw=primes;//把数组primes的首地址赋给了PW
n=2;//
*pw++=2;*pw++=3;// 这句的意思是;primes[0]=2;primes[1]=3，不是把pw付给两个整数。。
i=5; //i=5;
do //循环结束条件: r为负.或.i>q*q
{
pr=primes;//(答案见B)为什么把数组的首地址赋给了PR？
do
{ //
p=*pr++; //
q=i/p; // 判断数组内的数是否能被下一能即将加入数组的数整除，能，则不加入数组，不能，则加入数组。
r=i-q*p; //
} while (r&&i<q*q); //
if (r) // 条件为0时为假,

*pw++=i; //给下一个元素赋值
n++; //n值变化范围:2,3,4,5,6,7,8,9,10
}
i+=2; // i=7; i=9 i=11 ………………
} while (n<MAX);
j=0;
pr=primes;//为什么再次把数组的首地址赋给了PR？ 见答案c.
/*______________________________________________________________________________________*/
for (i=0;i<MAX;++i) //遍历数组..
{
cout<<*pr++<<setw(3);//显示数据...primes[]
if (++j==10)当j=9时,++j=10.换行.重置j=0;
{
cout<<endl;
j=0;
}
}
}
形成一个十元素数组，数组内的元素不能被其它元素整除。(说白了就是求前十个素数)
pw的能功是加入一个新的数到数组。pr的功能是次访问数组内的每一个数
答案a:为什么要定义两个指针.
因为,一个指针用于修改数组数据,一个指针用于遍历数组两指针权限不一样.在下面程序中,凡是涉级修改的都是用的PW.查看的都用的是pr. （这也是编程的思想）
还有，不能替换，两个指针，在同一时刻所用处于的位置是不一样的。 。如果，替换了会很麻烦。就像你编写冒泡算法一样，两个数据指针位置是不一样的。
答案B：答案A提到过。每一次外部循环完成，都要对比下一个即将加入数组的数，是否能整除数组里的数，如果不把指针重置，指针没有法访问指针之前的数。，则没有法对比。。，pr指针重置。。，pr指针用于内层循环遍历数据。它要依次访问数组内的每一个数。
判读是否加入数组。
答案c:因为，在接下来的程序还会用到，pr来遍历数组。。如果不重置，则指针没有法访问指针之前的数。

题外话，5楼的同志，你不要乱教哦。。
primes[MAX];//正常情况下，此处是：primes[]={0,0,0,0,0,0,0,0,0,0}

修改下哈。。
primes[]={1111……，1111……，1111……，1111……，……}（二进制）

如果数组定义了， 未被使用的元素，默认为全1（二进制）
由于，计算机中，二进制数第一位为，符号位，所以，示被定义的元素位为，一个无穷小的数。
有多小，得看你计算机是多少位了。 。
再谈谈你这个数所导置的后果，0在计算机中，被认为是，假，非0则为真。。
你这样认为，直接导致了后面的if语句，可能误判。。。。。后果，。。。
不用谢我哈。

Answer 2

void main()
{
int i,j,n,p,r,primes[MAX];
int *pw,*pr;//如果仅仅用于遍历数组,可以用数组首地址,但是用指针更加灵活,可以"停在某个地方"
long q;
pw=primes;//这里是为了下面的赋值, *pw++=2;*pw++=3
n=2;
*pw++=2;*pw++=3;//自加,相当于primes[0] = 2,primes[1]=3
i=5;
do
{
pr=primes;//因为pw已经移动了 不再指向首地址.下面pw还有别的用处,所以不能再用pw了
do
{
p=*pr++;
q=i/p;
r=i-q*p;
} while (r&&i<q*q);
if (r)
{
*pw++=i;
n++;
}
i+=2;
} while (n<MAX);
j=0;
pr=primes;//同上,pr重新指向数组首地址,这样才能遍历输出啊
for (i=0;i<MAX;++i)
{
cout<<*pr++<<setw(3);
if (++j==10)
{
cout<<endl;
j=0;
}
}
}

Answer 3

//计算并输出前10个素数
#include <iostream>
#include <iomanip>
using namespace std;//使用命名空间std
#define MAX 10//宏定义,编译器遇到MAX替换成10
void main()
{
int i,j,n,p,r,primes[MAX];
int *pw,*pr;//指针是可以移动的，而数组首地址是常量，不能够++
long q;
pw=primes;//把数组的首地址赋给PW，PW指向数组第一个元素
n=2;
*pw++=2;//相当于两个语句 *pw=2; pw++; 第一个素数为2
*pw++=3;//同理，给pw指向的变量赋值3，第二个素数为3，pw指向下一个变量
i=5;
do
{
pr=primes;//在下面的内层do循环中,pr不断++，外层do循环开始时，保持pr指向数组的第一个元素
do
{
p=*pr++;
q=i/p;
r=i-q*p;
} while (r&&i<q*q);//当r不等于0 且i<q的平方时，继续do循环
if (r)
{
*pw++=i;
n++;
}
i+=2;//偶数除了2，不可能是素数，所以i递增2，判断i是否为素数
} while (n<MAX);
j=0;
pr=primes;//为了输出所有素数，又重新指向数组的开头
for (i=0;i<MAX;++i)
{
cout<<*pr++<<setw(3);
if (++j==10)
{
cout<<endl;
j=0;
}
}
}

Answer 4

#include <iostream>
#include <iomanip>
using namespace std;
#define MAX 10
void main()
{
int i,j,n,p,r,primes[MAX];
int *pw,*pr;//为什么要定义这两个指针？这两个指针在下面程序中都指向了数组首地址 那么干脆就把所有pw,pr都替换成数组首地址不就行了？可是替换后又不能得出结果。为什么？
long q;
pw=primes;//为什么把数组的首地址赋给了PW？
n=2;
*pw++=2;*pw++=3;//为什么pw的值同时赋给了两个整数？//primes[0]=2,primes[1]=3因为第一个素数是2，第二个素数为3.
i=5;
do
{
pr=primes;//为什么把数组的首地址赋给了PR？
do
{
p=*pr++;//递归来获取primes中的值。
q=i/p;
r=i-q*p;
} while (r&&i<q*q);
if (r)
{
*pw++=i;//将对应的i值赋给*pw
n++;
}
i+=2;
} while (n<MAX);
j=0;
pr=primes;//为什么再次把数组的首地址赋给了PR？ 这个时候的primes中的值是修改后的素数值了。赋值为了显示出来。
for (i=0;i<MAX;++i)
{
cout<<*pr++<<setw(3);
if (++j==10)
{
cout<<endl;
j=0;
}
}
}

Answer 5

数组首地址复制主要是用来保存 然后地址++就挨边输出了！
*pw++=2;*pw++=3;这个是把2和3挨边复制给pw指针指向的地址空间
你要看清是有++的

Answer 6

void main()
{
int i,j,n,p,r,
primes[MAX];//正常情况下，此处是：primes[]={0,0,0,0,0,0,0,0,0,0}
int *pw,*pr;//为什么要定义这两个指针？这两个指针在下面程序中都指向了数组首地址 那么干脆就把所有pw,pr都替换成数组首地址不就行了？可是替换后又不能得出结果。为什么？//为了指针的灵活切换，比如第一个do循环里面多次：pr=primes,实际上，两个指针都在不停地移动
long q;
pw=primes;//为什么把数组的首地址赋给了PW？
n=2;
*pw++=2;*pw++=3;//为什么pw的值同时赋给了两个整数？
//此后：primes[]={2,3,*0,0,0,0,0,0,0,0}，pw指向了*0处
i=5;
do
{
pr=primes;//为什么把数组的首地址赋给了PR？//便于每次都从头开始处理
do
{
p=*pr++;//获得当前pr指向处的数据，如第一次进入 p = 2,pr指向下一个位置
q=i/p;
r=i-q*p;//上面两句表示r = i%p;
} while (r&&i<q*q);//用do...while...就是希望至少使用一次函数体，条件是r > 0 并且 i<q*q
if (r)//如果r > 0
{
*pw++=i;//将pw指向处赋值为i，然后pw向后移动一位
n++;//数组计数加一，保证不越界
}
i+=2;
} while (n<MAX);//保证不越界
j=0;
pr=primes;//为什么再次把数组的首地址赋给了PR？此处是为了从头遍历此数组
for (i=0;i<MAX;++i)
{
cout<<*pr++<<setw(3);//将值打印出来
if (++j==10)
{
cout<<endl;//表示此处结束了
j=0;
}
}
}