Any type of pointer can point to anything?

Question

0.00/5 (No votes)

See more:

Is this statement correct? Can any "TYPE" of pointer can point to any other type?
Because i believe so , still have doubts.
So why are then pointers declared for definite types? eg. int or char ones?
The one explanation i could get was because if an int type pointer was being pointed to char array, then when pointer will be incremented , the pointer will jump from 0 position to directly 2 position , skipping 1 position in between( because int size=2).
And maybe because pointer just holds the address of a value , not the value itself eg. the int or double one.

So at what i am wrong? Was that statement correct? As i read that at someone's answer to stackoverflow question?

Posted 31-Oct-13 4:48am

Abhinav Gauniyal

Updated 31-Oct-13 4:51am

v2

Add a Solution

3 solutions

Solution 1

All pointers hold a (possibly invalid) address. However the C++ programming language is strongly typed: the compiler detects pointer type mismatches.
And, yes, pointer arithmetic relies on pointed type size.

Please see this page: "Pointers" at cplusplus.com[^], you may learn also about the special rule of the void pointer.

Posted 31-Oct-13 4:56am

CPallini

Updated 31-Oct-13 5:01am

v4

Comments

Abhinav Gauniyal 31-Oct-13 11:02am

So can i say that any type of pointer is able to point to anything? And i have also listened about that due to this characteristic , we can convert them from one data type to another?

And just pointer arithmetic relies only or some other functioning too?

Sorry for asking too many questions , but i want to get a strong hold of this topic :)

Solution 3

C#

#include <stdio.h>
#include<string.h>

char f[10000];
char factorial[1010][10000];

void multiply(int k)
{
int cin,sum,i;
int len = strlen(f);
cin=0;
i=0;
while(i<len)
{
sum=cin+(f[i] - '0') * k;
f[i] = (sum % 10) + '0';
i++;
cin = sum/10;
}
while(cin>0)
{
f[i++] = (cin%10) + '0';
cin/=10;
}
f[i]='\0';
for(int j=0;j<i;j++)
factorial[k][j]=f[j];

factorial[k][i]='\0';
}
void fac()
{
int k;
strcpy(f,"1");
for(k=2;k<=1000;k++)
multiply(k);
}
void print(int n)
{
int i;
int len = strlen(factorial[n]);
printf("%d!\n",n);
for(i=len-1;i>=0;i--)
printf("%c",factorial[n][i]);
printf("\n");
}
int main()
{
int n;
factorial[0][0]='1';
factorial[1][0]='1';
fac();
while(scanf("%d",&n)==1){
print(n);
}
return 0;
}

Posted 31-Oct-13 5:34am

Member 10369941

Comments

Abhinav Gauniyal 31-Oct-13 12:01pm

My brain is blown out :( , just want a hint probably !

Matt T Heffron 31-Oct-13 13:54pm

This "solution" has nothing to do with the question asked!

Add a Solution

Add your solution here

Treat my content as plain text, not as HTML

Preview 0

…

Existing Members

Sign in to your account

...or Join us

Download, Vote, Comment, Publish.

Your Email
Password
Forgot your password?

Your Email
This email is in use. Do you need your password?
Optional Password

I have read and agree to the Terms of Service and Privacy Policy
Please subscribe me to the CodeProject newsletters

When answering a question please:

Read the question carefully.
Understand that English isn't everyone's first language so be lenient of bad spelling and grammar.
If a question is poorly phrased then either ask for clarification, ignore it, or edit the question and fix the problem. Insults are not welcome.
Don't tell someone to read the manual. Chances are they have and don't get it. Provide an answer or move on to the next question.

Let's work to help developers, not make them feel stupid.

This content, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Orjan Westin · Accepted Answer · 2013-10-31T05:07:00

Yes and no. All pointers are the same - they contain an address in memory. That is why it is legal in C and C++ to convert any pointer, regardless of type, to a void*

But when you work with pointers, their type does make a difference. Both when iterating over elements in an array (for this to work, the size of the elements must be known to the compiler, and the way we tell the compiler is through the type of the pointer), and when dereferencing a pointer to get to the data it points to. That is why casts between different types is dangerous.

<br />
int a = 1234; // a value on the stack<br />
int* b = &a;  // points to a on the stack<br />
char* c = (char*)b; // the same address,<br />
                    // but the contents <br />
                    // will be interpreted<br />
                    // differently<br />
char d = *c; // What does d contain?<br />
long* e = (long*)b; // again<br />
long f = *e; // What does f contain?<br />
             // (This reads more than was <br />
             // originally put on the stack<br />
             // so will lead to undefined<br />
             // behaviour.)<br />