473,226 Members | 1,442 Online
Bytes | Software Development & Data Engineering Community
Post Job

Home Posts Topics Members FAQ

Join Bytes to post your question to a community of 473,226 software developers and data experts.

return discards qualifiers from pointer target type

i Group,

to my understanding, defining a function parameter as "const" means that
the function is not going to change it.

Why does the compiler says "return discards qualifiers from pointer
target type" when I *access* a member of an argument defined as const?

Please see the code below:

/*** START TEST.C ***/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#define MAX_NAME_SIZE 80
#define MY_NAME "This is my name"

struct my_s
{
char mys_name[MAX_NAME_SIZE+1];
};

void set_mys_name(struct my_s *, const char *);
char *get_mys_name(const struct my_s *);

int main(void) {
struct my_s *mysp;

mysp = malloc(sizeof *mysp);

set_mys_name(mysp, MY_NAME);

printf("My name is %s\n", get_mys_name(mysp));

return (0);
}

void
set_mys_name(struct my_s *mys, const char *name)
{
if(!mys) return;
strncpy(mys->mys_name, name, MAX_NAME_SIZE);
}

char *
get_mys_name(const struct my_s *mys)
{
if(!mys) return (NULL);
return (mys->mys_name);
}
/*** START TEST.C ***/
gcc -Wall -o test test.c
test.c: In function `get_mys_name':
test.c:39: warning: return discards qualifiers from pointer target type
./test
My name is This is my name
Thank you!
--
Pietro Cerutti

PGP Public Key:
http://gahr.ch/pgp
Aug 28 '07 #1
17 12677
Pietro Cerutti <ga**@gahr.chwrites:
i Group,

to my understanding, defining a function parameter as "const" means that
the function is not going to change it.

Why does the compiler says "return discards qualifiers from pointer
target type" when I *access* a member of an argument defined as const?
<snip>
struct my_s
{
char mys_name[MAX_NAME_SIZE+1];
};
....
char *
get_mys_name(const struct my_s *mys)
{
if(!mys) return (NULL);
return (mys->mys_name);
}
The object pointed to by mys is const. This function returns a plain
(non-const) pointer to part of it (the mys_name array). The caller
could modify the contents of this array through this ponter. The
compiler is warning you that this function breaks the constness of the
object its parameter points to.

--
Ben.
Aug 28 '07 #2
Ben Bacarisse wrote:
Pietro Cerutti <ga**@gahr.chwrites:
>i Group,

to my understanding, defining a function parameter as "const" means that
the function is not going to change it.

Why does the compiler says "return discards qualifiers from pointer
target type" when I *access* a member of an argument defined as const?

<snip>
>struct my_s
{
char mys_name[MAX_NAME_SIZE+1];
};
...
>char *
get_mys_name(const struct my_s *mys)
{
if(!mys) return (NULL);
return (mys->mys_name);
}

The object pointed to by mys is const. This function returns a plain
(non-const) pointer to part of it (the mys_name array). The caller
could modify the contents of this array through this ponter. The
compiler is warning you that this function breaks the constness of the
object its parameter points to.
So, so to speak, when a struct is defined as const, each pointer trying
to reference to a member of that struct using the "->" operator has to
be const as well.
Am I correct?

Thank you for your input!
--
Pietro Cerutti

PGP Public Key:
http://gahr.ch/pgp
Aug 28 '07 #3
Ben Bacarisse wrote:
Pietro Cerutti <ga**@gahr.chwrites:
>i Group,

to my understanding, defining a function parameter as "const" means that
the function is not going to change it.

Why does the compiler says "return discards qualifiers from pointer
target type" when I *access* a member of an argument defined as const?

<snip>
>struct my_s
{
char mys_name[MAX_NAME_SIZE+1];
};
...
>char *
get_mys_name(const struct my_s *mys)
{
if(!mys) return (NULL);
return (mys->mys_name);
}

The object pointed to by mys is const. This function returns a plain
(non-const) pointer to part of it (the mys_name array). The caller
could modify the contents of this array through this ponter. The
compiler is warning you that this function breaks the constness of the
object its parameter points to.
Sorry for double posting:
I though that a const in a parameter only meant that the function itself
isn't going to modify the parameter. The object itself (the struct)
hasn't been defined as const, so a function calling get_mys_name() has
the right to modify the name using the pointer returned by the function.
What's wrong with it?
--
Pietro Cerutti

PGP Public Key:
http://gahr.ch/pgp
Aug 28 '07 #4
Pietro Cerutti wrote:
>
.... snip ...
>
I though that a const in a parameter only meant that the function
itself isn't going to modify the parameter. The object itself (the
struct) hasn't been defined as const, so a function calling
get_mys_name() has the right to modify the name using the pointer
returned by the function. What's wrong with it?
Because you aren't returning the component of the original. You
are returning a component of the functional parameter, which you
promised not to disturb.

--
Chuck F (cbfalconer at maineline dot net)
Available for consulting/temporary embedded and systems.
<http://cbfalconer.home.att.net>

--
Posted via a free Usenet account from http://www.teranews.com

Aug 28 '07 #5
Pietro Cerutti wrote:
>
.... snip ...
>
Why does the compiler says "return discards qualifiers from pointer
target type" when I *access* a member of an argument defined as const?
Because the struct is const. You can't have a const struct without
having all the components automatically being const.

--
Chuck F (cbfalconer at maineline dot net)
Available for consulting/temporary embedded and systems.
<http://cbfalconer.home.att.net>

--
Posted via a free Usenet account from http://www.teranews.com

Aug 28 '07 #6
Pietro Cerutti <ga**@gahr.chwrites:
Ben Bacarisse wrote:
>Pietro Cerutti <ga**@gahr.chwrites:
<snip>
>>struct my_s
{
char mys_name[MAX_NAME_SIZE+1];
};
...
>>char *
get_mys_name(const struct my_s *mys)
{
if(!mys) return (NULL);
return (mys->mys_name);
}

The object pointed to by mys is const. This function returns a plain
(non-const) pointer to part of it (the mys_name array). The caller
could modify the contents of this array through this ponter. The
compiler is warning you that this function breaks the constness of the
object its parameter points to.

So, so to speak, when a struct is defined as const, each pointer trying
to reference to a member of that struct using the "->" operator has to
be const as well.
Am I correct?
Yes. Your language is a little vague but that is the gist of it.
Section 6.5.2.3 paragraphs 3 and 4 if you want chapter and verse.

When you access a struct member using either . or ->, the expression
takes on the type of the member, qualified in the same way as the
struct object (const is a type qualifier).

--
Ben.
Aug 28 '07 #7
Ben Bacarisse wrote:
Pietro Cerutti <ga**@gahr.chwrites:
>Ben Bacarisse wrote:
>>Pietro Cerutti <ga**@gahr.chwrites:
<snip>
>>>struct my_s
{
char mys_name[MAX_NAME_SIZE+1];
};
...
char *
get_mys_name(const struct my_s *mys)
{
if(!mys) return (NULL);
return (mys->mys_name);
}
The object pointed to by mys is const. This function returns a plain
(non-const) pointer to part of it (the mys_name array). The caller
could modify the contents of this array through this ponter. The
compiler is warning you that this function breaks the constness of the
object its parameter points to.
So, so to speak, when a struct is defined as const, each pointer trying
to reference to a member of that struct using the "->" operator has to
be const as well.
Am I correct?

Yes. Your language is a little vague but that is the gist of it.
Section 6.5.2.3 paragraphs 3 and 4 if you want chapter and verse.
English's not my mother language..
>
When you access a struct member using either . or ->, the expression
takes on the type of the member, qualified in the same way as the
struct object (const is a type qualifier).
Clear, thank you!
--
Pietro Cerutti

PGP Public Key:
http://gahr.ch/pgp
Aug 28 '07 #8
Pietro Cerutti <ga**@gahr.chwrites:
Ben Bacarisse wrote:
>Pietro Cerutti <ga**@gahr.chwrites:
<snip>
>>char *
get_mys_name(const struct my_s *mys)
{
if(!mys) return (NULL);
return (mys->mys_name);
}

The object pointed to by mys is const. This function returns a plain
(non-const) pointer to part of it (the mys_name array). The caller
could modify the contents of this array through this ponter. The
compiler is warning you that this function breaks the constness of the
object its parameter points to.

Sorry for double posting:
I though that a const in a parameter only meant that the function itself
isn't going to modify the parameter. The object itself (the struct)
hasn't been defined as const, so a function calling get_mys_name() has
the right to modify the name using the pointer returned by the function.
What's wrong with it?
You are little confused about what is const. Your function declares
mys as a pointer to a constant my_s structure. The parameter itself,
mys, is not at all constant. The function can do 'mys += 1;' if it
likes -- it can't do 'mys->mys_name[0] = 'a';' because the whole
structure pointer to by mys is constant.

A few examples:

struct s x; /* x is a struct s */
const struct s y; /* y is a constant struct s */
struct s const w; /* ditto, but some find this one odd to read! */
struct s *const p; /* p is constant pointer to a (non-const) struct */
const struct s *q; /* q is a pointer to a constant struct s */
const struct s *const r; /* both p and the struct it points to are const */

Does that help at all?

--
Ben.
Aug 28 '07 #9
Ben Bacarisse wrote:
Pietro Cerutti <ga**@gahr.chwrites:
>Ben Bacarisse wrote:
>>Pietro Cerutti <ga**@gahr.chwrites:
<snip>
>>>char *
get_mys_name(const struct my_s *mys)
{
if(!mys) return (NULL);
return (mys->mys_name);
}
The object pointed to by mys is const. This function returns a plain
(non-const) pointer to part of it (the mys_name array). The caller
could modify the contents of this array through this ponter. The
compiler is warning you that this function breaks the constness of the
object its parameter points to.
Sorry for double posting:
I though that a const in a parameter only meant that the function itself
isn't going to modify the parameter. The object itself (the struct)
hasn't been defined as const, so a function calling get_mys_name() has
the right to modify the name using the pointer returned by the function.
What's wrong with it?

You are little confused about what is const. Your function declares
mys as a pointer to a constant my_s structure. The parameter itself,
mys, is not at all constant. The function can do 'mys += 1;' if it
likes -- it can't do 'mys->mys_name[0] = 'a';' because the whole
structure pointer to by mys is constant.

A few examples:

struct s x; /* x is a struct s */
const struct s y; /* y is a constant struct s */
struct s const w; /* ditto, but some find this one odd to read! */
struct s *const p; /* p is constant pointer to a (non-const) struct */
const struct s *q; /* q is a pointer to a constant struct s */
const struct s *const r; /* both p and the struct it points to are const */

Does that help at all?
No, /*that*/ was clear. I do understand the the pointer is not const,
the structure is, and therefore you haven't got the right to modify its
members.

Now I understood that you can't return members of the structure without
declaring them const as well.

What I still don't understand is why: if the structure is const only
inside the function receiving it as a const parameter (thus not const at
the caller) the function should be able to return to the caller members
of the struct not declared as const, since the caller has the right to
modify them.

--
Pietro Cerutti

PGP Public Key:
http://gahr.ch/pgp
Aug 28 '07 #10
Pietro Cerutti <ga**@gahr.chwrites:
Ben Bacarisse wrote:
<snip>
>A few examples:

struct s x; /* x is a struct s */
const struct s y; /* y is a constant struct s */
struct s const w; /* ditto, but some find this one odd to read! */
struct s *const p; /* p is constant pointer to a (non-const) struct */
const struct s *q; /* q is a pointer to a constant struct s */
const struct s *const r; /* both p and the struct it points to are const */

Does that help at all?

No, /*that*/ was clear. I do understand the the pointer is not const,
the structure is, and therefore you haven't got the right to modify its
members.
OK, but just so you see why I thought you had that confused, here is
what you said:

| I though that a const in a parameter only meant that the function itself
| isn't going to modify the parameter.

"modify the parameter" is confusing here. Strictly speaking, the
parameter is mys and not the thing mys points to. mys can be modified
by this function because it is not declared as being const. I get
that you get that, but it was not at all clear from the above!
Now I understood that you can't return members of the structure without
declaring them const as well.

What I still don't understand is why: if the structure is const only
inside the function receiving it as a const parameter (thus not const at
the caller) the function should be able to return to the caller members
of the struct not declared as const, since the caller has the right to
modify them.
The reason is that the compiler can't know and thus needs a general
rule:

struct s { char name[100]; };

char *open_up(const struct s *sp)
{
return sp->name; /* example code: this is an error! */
}

void safe(void)
{
struct s data;
open_up(&data)[0] = 'a';
}

void unsafe(void)
{
const struct s data;
open_up(&data)[0] = 'a';
}

You are right that the function 'open_up' does not allow 'safe' to do
anything that it can't already do, but 'usafe' should be stopped. How
can the compiler tell the difference? All three can be compiled
separately, of course.

When an object is declared const, it does not just mean that you won't
change it. It also means that you won't hand out the means by which
it may be changed (not at least with out a diagnostic message).

--
Ben.
Aug 28 '07 #11
Ben Bacarisse wrote:
Pietro Cerutti <ga**@gahr.chwrites:
>Ben Bacarisse wrote:
<snip>
>>A few examples:

struct s x; /* x is a struct s */
const struct s y; /* y is a constant struct s */
struct s const w; /* ditto, but some find this one odd to read! */
struct s *const p; /* p is constant pointer to a (non-const) struct */
const struct s *q; /* q is a pointer to a constant struct s */
const struct s *const r; /* both p and the struct it points to are const */

Does that help at all?
No, /*that*/ was clear. I do understand the the pointer is not const,
the structure is, and therefore you haven't got the right to modify its
members.

OK, but just so you see why I thought you had that confused, here is
what you said:

| I though that a const in a parameter only meant that the function itself
| isn't going to modify the parameter.

"modify the parameter" is confusing here. Strictly speaking, the
parameter is mys and not the thing mys points to. mys can be modified
by this function because it is not declared as being const. I get
that you get that, but it was not at all clear from the above!
>Now I understood that you can't return members of the structure without
declaring them const as well.

What I still don't understand is why: if the structure is const only
inside the function receiving it as a const parameter (thus not const at
the caller) the function should be able to return to the caller members
of the struct not declared as const, since the caller has the right to
modify them.

The reason is that the compiler can't know and thus needs a general
rule:

struct s { char name[100]; };

char *open_up(const struct s *sp)
{
return sp->name; /* example code: this is an error! */
}

void safe(void)
{
struct s data;
open_up(&data)[0] = 'a';
}

void unsafe(void)
{
const struct s data;
open_up(&data)[0] = 'a';
}

You are right that the function 'open_up' does not allow 'safe' to do
anything that it can't already do, but 'usafe' should be stopped. How
can the compiler tell the difference? All three can be compiled
separately, of course.

When an object is declared const, it does not just mean that you won't
change it. It also means that you won't hand out the means by which
it may be changed (not at least with out a diagnostic message).
Yep. Got it. Thanks again!
--
Pietro Cerutti

PGP Public Key:
http://gahr.ch/pgp
Aug 28 '07 #12
On Aug 28, 3:42 pm, Pietro Cerutti <g...@gahr.chwrote:
i Group,

to my understanding, defining a function parameter as "const" means that
the function is not going to change it.
'Const' is a very poor term used in C language that misleads many
people initially.
Const means 'Read-Only'. It is a qualifier which states that it cannot
be changed using
that particular variable. But, it can be manipulated by accessing the
address of it using pointers.

Karthik Balaguru

Aug 28 '07 #13
karthikbalaguru <ka***************@gmail.comwrites:
'Const' is a very poor term used in C language that misleads many
people initially.
Const means 'Read-Only'. It is a qualifier which states that it cannot
be changed using
that particular variable. But, it can be manipulated by accessing the
address of it using pointers.
Actually, the term is 'const'. In C, the case of letters is
important, so you should take care to be precise.

There is a little more confusion surrounding the C use of 'const'
than your article lets on. In particular, its meaning is quite
different when it is applied to an object definition versus the
target of a pointer. An object whose definition is qualified
with 'const' may not be modified; attempting to modify it yields
undefined behavior. On the other hand, you can always cast
away 'const' from a 'const'-qualified pointer type, and then
attempt to modify the object pointed to. Whether that is valid
depends entirely on how the target object was defined: if it is
modifiable (not 'const'-qualified, not a string literal, etc.),
then it is OK.
--
Just another C hacker.
Aug 28 '07 #14
On Tue, 28 Aug 2007 12:42:42 +0200, Pietro Cerutti <ga**@gahr.ch>
wrote:
>i Group,

to my understanding, defining a function parameter as "const" means that
the function is not going to change it.

Why does the compiler says "return discards qualifiers from pointer
target type" when I *access* a member of an argument defined as const?

Please see the code below:

/*** START TEST.C ***/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#define MAX_NAME_SIZE 80
#define MY_NAME "This is my name"

struct my_s
{
char mys_name[MAX_NAME_SIZE+1];
};

void set_mys_name(struct my_s *, const char *);
char *get_mys_name(const struct my_s *);

int main(void) {
struct my_s *mysp;

mysp = malloc(sizeof *mysp);

set_mys_name(mysp, MY_NAME);

printf("My name is %s\n", get_mys_name(mysp));

return (0);
}

void
set_mys_name(struct my_s *mys, const char *name)
{
if(!mys) return;
strncpy(mys->mys_name, name, MAX_NAME_SIZE);
}

char *
get_mys_name(const struct my_s *mys)
{
if(!mys) return (NULL);
return (mys->mys_name);
}
/*** START TEST.C ***/
gcc -Wall -o test test.c
test.c: In function `get_mys_name':
test.c:39: warning: return discards qualifiers from pointer target type
Based on the subsequent discussion, if you want get_mys_name to accept
a pointer to a non-const struct but still want the function to treat
it as const (so you get diagnostics if you try to modify it), one
approach would be

get_mys_name(struct my_s *pmys) /*const removed, p added*/
{
const struct my_s *mys = pmys;
if(!mys) return (NULL);
return (pmys->mys_name); /*only use pmys in return*/
}
Remove del for email
Aug 30 '07 #15
Barry Schwarz wrote:
On Tue, 28 Aug 2007 12:42:42 +0200, Pietro Cerutti <ga**@gahr.ch>
wrote:
>i Group,

to my understanding, defining a function parameter as "const" means that
the function is not going to change it.

Why does the compiler says "return discards qualifiers from pointer
target type" when I *access* a member of an argument defined as const?

Please see the code below:

/*** START TEST.C ***/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#define MAX_NAME_SIZE 80
#define MY_NAME "This is my name"

struct my_s
{
char mys_name[MAX_NAME_SIZE+1];
};

void set_mys_name(struct my_s *, const char *);
char *get_mys_name(const struct my_s *);

int main(void) {
struct my_s *mysp;

mysp = malloc(sizeof *mysp);

set_mys_name(mysp, MY_NAME);

printf("My name is %s\n", get_mys_name(mysp));

return (0);
}

void
set_mys_name(struct my_s *mys, const char *name)
{
if(!mys) return;
strncpy(mys->mys_name, name, MAX_NAME_SIZE);
}

char *
get_mys_name(const struct my_s *mys)
{
if(!mys) return (NULL);
return (mys->mys_name);
}
/*** START TEST.C ***/
>>>gcc -Wall -o test test.c
test.c: In function `get_mys_name':
test.c:39: warning: return discards qualifiers from pointer target type

Based on the subsequent discussion, if you want get_mys_name to accept
a pointer to a non-const struct but still want the function to treat
it as const (so you get diagnostics if you try to modify it), one
approach would be

get_mys_name(struct my_s *pmys) /*const removed, p added*/
{
const struct my_s *mys = pmys;
if(!mys) return (NULL);
return (pmys->mys_name); /*only use pmys in return*/
}

Thank you, unfortunately it doesn't help to reach my goal, which would
just be to inform the user that the function doesn't modify the
parameter. I though it could be done using simply the function signature.

--
Pietro Cerutti

PGP Public Key:
http://gahr.ch/pgp
Aug 30 '07 #16
Pietro Cerutti wrote:
Barry Schwarz wrote:
.... snip ...
>>
get_mys_name(struct my_s *pmys) /*const removed, p added*/ {
const struct my_s *mys = pmys;
if(!mys) return (NULL);
return (pmys->mys_name); /*only use pmys in return*/
}

Thank you, unfortunately it doesn't help to reach my goal, which
would just be to inform the user that the function doesn't modify
the parameter. I though it could be done using simply the function
signature.
Why the fuss? Simply define the function as:

char *get_mys_name(struct my_s *mys) /* const removed */ {
if (mys) return mys->mys_name;
return NULL;
}

No fuss, no muss, no complaints. Ball, keep eye on.

If the function handles objects that are initially const, use:

const char *get_mys_name(const struct my_s *mys) {
if (mys) return mys->mys_name;
return NULL;
}

and now errors will show up at the correct points.

--
Chuck F (cbfalconer at maineline dot net)
Available for consulting/temporary embedded and systems.
<http://cbfalconer.home.att.net>

--
Posted via a free Usenet account from http://www.teranews.com

Aug 30 '07 #17
On Thu, 30 Aug 2007 15:17:10 +0200, Pietro Cerutti <ga**@gahr.ch>
wrote:
>Barry Schwarz wrote:
>On Tue, 28 Aug 2007 12:42:42 +0200, Pietro Cerutti <ga**@gahr.ch>
wrote:
>>i Group,

to my understanding, defining a function parameter as "const" means that
the function is not going to change it.

Why does the compiler says "return discards qualifiers from pointer
target type" when I *access* a member of an argument defined as const?

Please see the code below:

/*** START TEST.C ***/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#define MAX_NAME_SIZE 80
#define MY_NAME "This is my name"

struct my_s
{
char mys_name[MAX_NAME_SIZE+1];
};

void set_mys_name(struct my_s *, const char *);
char *get_mys_name(const struct my_s *);

int main(void) {
struct my_s *mysp;

mysp = malloc(sizeof *mysp);

set_mys_name(mysp, MY_NAME);

printf("My name is %s\n", get_mys_name(mysp));

return (0);
}

void
set_mys_name(struct my_s *mys, const char *name)
{
if(!mys) return;
strncpy(mys->mys_name, name, MAX_NAME_SIZE);
}

char *
get_mys_name(const struct my_s *mys)
{
if(!mys) return (NULL);
return (mys->mys_name);
}
/*** START TEST.C ***/

gcc -Wall -o test test.c
test.c: In function `get_mys_name':
test.c:39: warning: return discards qualifiers from pointer target type

Based on the subsequent discussion, if you want get_mys_name to accept
a pointer to a non-const struct but still want the function to treat
it as const (so you get diagnostics if you try to modify it), one
approach would be

get_mys_name(struct my_s *pmys) /*const removed, p added*/
{
const struct my_s *mys = pmys;
if(!mys) return (NULL);
return (pmys->mys_name); /*only use pmys in return*/
}


Thank you, unfortunately it doesn't help to reach my goal, which would
just be to inform the user that the function doesn't modify the
parameter. I though it could be done using simply the function signature.
In that case, go back to your original code and add a *single* cast to
your return statement.
Remove del for email
Sep 1 '07 #18

This thread has been closed and replies have been disabled. Please start a new discussion.

Similar topics

0
by: Juan Carlos CORUÑA | last post by:
Hello all, I have developed an automation server using Mark's win32 extensions and I must return a IStream COM object from one method of the automation server. Here is an extract of my code:...
6
by: Jason | last post by:
I have a function (Inet_ntop) that returns const char * and if I try to assign that return value to a char * variable, I get the gcc error message: warning: assignment discards qualifiers from...
12
by: Charlie Zender | last post by:
Hi, I am unable to compile a large body of code with extremely pedantic compile time checks activate, so that warnings cause errors. With GCC 3.3.1, I do this with gcc -std=c99 -pedantic...
8
by: Roger Leigh | last post by:
-----BEGIN PGP SIGNED MESSAGE----- Hash: SHA1 A lot of functions use const pointer arguments. If I have a non-const pointer, it is transparently made const when I pass it to the function, e.g....
2
by: Markus Dehmann | last post by:
I am trying to make a pair with a string and an auto_ptr: #include <iostream> #include <map> using namespace std; int main(){ auto_ptr<intp(new int(3)); make_pair("x",p); }
4
by: rohitsagar | last post by:
I want to do fork from a program Code is very simple, below is the code, it just execute a executable called a.exe, I want to run a.exe 600 times. #include<stdio.h> #include<stdlib.h> void...
2
by: Thelma Lubkin | last post by:
I use my own matrix and vector classes. I wrote them before such things were generally available and I've stuck with them ever since. I've just added an Octonion class derived from the vectors...
4
by: Andre | last post by:
Hi All, When I compile the following piece of code with gcc, I get 3 "warning: initialization discards qualifiers from pointer target type" messages which refer to the 3 lines marked in the...
49
by: Davy | last post by:
Hi all, I am writing a function, which return the pointer of the int. But it seems to be wrong. Any suggestion? int * get_p_t(int t) { return &t; } int main()
1
isladogs
by: isladogs | last post by:
The next online meeting of the Access Europe User Group will be on Wednesday 6 Dec 2023 starting at 18:00 UK time (6PM UTC) and finishing at about 19:15 (7.15PM). In this month's session, Mike...
0
by: veera ravala | last post by:
ServiceNow is a powerful cloud-based platform that offers a wide range of services to help organizations manage their workflows, operations, and IT services more efficiently. At its core, ServiceNow...
3
isladogs
by: isladogs | last post by:
The next Access Europe meeting will be on Wednesday 3 Jan 2024 starting at 18:00 UK time (6PM UTC) and finishing at about 19:15 (7.15PM). For other local times, please check World Time Buddy In...
0
by: jianzs | last post by:
Introduction Cloud-native applications are conventionally identified as those designed and nurtured on cloud infrastructure. Such applications, rooted in cloud technologies, skillfully benefit from...
2
by: jimatqsi | last post by:
The boss wants the word "CONFIDENTIAL" overlaying certain reports. He wants it large, slanted across the page, on every page, very light gray, outlined letters, not block letters. I thought Word Art...
0
by: fareedcanada | last post by:
Hello I am trying to split number on their count. suppose i have 121314151617 (12cnt) then number should be split like 12,13,14,15,16,17 and if 11314151617 (11cnt) then should be split like...
0
Git
by: egorbl4 | last post by:
Скачал я git, хотел начать настройку, а там вылезло вот это Что это? Что мне с этим делать? ...
1
by: davi5007 | last post by:
Hi, Basically, I am trying to automate a field named TraceabilityNo into a web page from an access form. I've got the serial held in the variable strSearchString. How can I get this into the...
0
by: MeoLessi9 | last post by:
I have VirtualBox installed on Windows 11 and now I would like to install Kali on a virtual machine. However, on the official website, I see two options: "Installer images" and "Virtual machines"....

By using Bytes.com and it's services, you agree to our Privacy Policy and Terms of Use.

To disable or enable advertisements and analytics tracking please visit the manage ads & tracking page.