struct and pointer question

Discussion in 'C Programming' started by Bill Cunningham, Sep 14, 2012.

  1. In fread/fwrite the first parameter takes a pointer to a void. The
    generic pointer. I wrote a struct that would insert the in file name and out
    file name through fopen. My struct looks like this.

    struct param {
    char *infile;
    char *outfile;
    void *buf;
    };
    In the function I wrote that takes struct param as a type I don't know how
    to chose a type in the struct for void *. I have:

    fread(p.buf,1,sizeof p.buf,p.infile);

    Is there no way to change a return type as declared in a struct's elements ?
    The elements are all of type struct param now.
    Should I just leave the void * variable out of the struct and declare it
    as a type char * or int * or size_t * whatever I want later as I need it?

    Is this clear?

    Bill
     
    Bill Cunningham, Sep 14, 2012
    #1
    1. Advertising

  2. "Bill Cunningham" <> writes:

    > In fread/fwrite the first parameter takes a pointer to a void. The
    > generic pointer. I wrote a struct that would insert the in file name and out
    > file name through fopen. My struct looks like this.
    >
    > struct param {
    > char *infile;
    > char *outfile;
    > void *buf;
    > };
    > In the function I wrote that takes struct param as a type I don't know how
    > to chose a type in the struct for void *. I have:
    >
    > fread(p.buf,1,sizeof p.buf,p.infile);


    You probably want buf to be array, not a pointer. This might be what
    you mean by the fact that you " don't know how to chose a type in the
    struct for void *". I suspect that means you don't know what type buf
    should have.

    If you don't want an array in the struct then the fread call is probably
    wrong. The count argument should be the number of characters that you
    want to read (size of p.buf is a small number like 4 or 8 -- it's the
    size of a pointer).

    > Is there no way to change a return type as declared in a struct's
    > elements ?


    I don't know what this means. Functions have a return type, but a
    struct's elements just has a type.

    > The elements are all of type struct param now.


    That does not make sense. Two are of type char * and one is of type
    void *.

    > Should I just leave the void * variable out of the struct and declare it
    > as a type char * or int * or size_t * whatever I want later as I need
    > it?


    It's impossible to tell because you give no context. What is this
    struct for? It may be fine as it is of it could be all wrong. Without
    context is just three bit of data collected together for no apparent
    reason.

    > Is this clear?


    Not without more context.

    --
    Ben.
     
    Ben Bacarisse, Sep 14, 2012
    #2
    1. Advertising

  3. Ben Bacarisse wrote:
    > "Bill Cunningham" <> writes:
    >
    >> In fread/fwrite the first parameter takes a pointer to a void.
    >> The generic pointer. I wrote a struct that would insert the in file
    >> name and out file name through fopen. My struct looks like this.
    >>
    >> struct param {
    >> char *infile;
    >> char *outfile;
    >> void *buf;
    >> };
    >> In the function I wrote that takes struct param as a type I don't
    >> know how to chose a type in the struct for void *. I have:
    >>
    >> fread(p.buf,1,sizeof p.buf,p.infile);

    >
    > You probably want buf to be array, not a pointer. This might be what
    > you mean by the fact that you " don't know how to chose a type in the
    > struct for void *". I suspect that means you don't know what type buf
    > should have.
    >
    > If you don't want an array in the struct then the fread call is
    > probably wrong. The count argument should be the number of
    > characters that you want to read (size of p.buf is a small number
    > like 4 or 8 -- it's the size of a pointer).
    >
    >> Is there no way to change a return type as declared in a struct's
    >> elements ?

    >
    > I don't know what this means. Functions have a return type, but a
    > struct's elements just has a type.
    >
    >> The elements are all of type struct param now.

    >
    > That does not make sense. Two are of type char * and one is of type
    > void *.
    >
    >> Should I just leave the void * variable out of the struct and
    >> declare it as a type char * or int * or size_t * whatever I want
    >> later as I need
    >> it?

    >
    > It's impossible to tell because you give no context. What is this
    > struct for? It may be fine as it is of it could be all wrong.
    > Without context is just three bit of data collected together for no
    > apparent reason.
    >
    >> Is this clear?

    >
    > Not without more context.


    I suspect the author of fread and fwrite used the generic pointer type
    for a reason. So you could change array types like for example char
    buf[200]; or int buf [1000]; I usually use a size_t as the array type. But
    putting the type void * in the prototype gives flexibility normally. But
    what about in the struct? Do I need to change the type to int * or size_t *
    for the array type. I don't know how to change it later to a int * or char *
    ..

    Make Sense? If not I'll post some code.

    Bill
     
    Bill Cunningham, Sep 14, 2012
    #3
  4. On Thu, 13 Sep 2012 23:23:06 -0400, "Bill Cunningham"
    <> wrote:

    >Ben Bacarisse wrote:
    >> "Bill Cunningham" <> writes:
    >>
    >>> In fread/fwrite the first parameter takes a pointer to a void.
    >>> The generic pointer. I wrote a struct that would insert the in file
    >>> name and out file name through fopen. My struct looks like this.
    >>>
    >>> struct param {
    >>> char *infile;
    >>> char *outfile;
    >>> void *buf;
    >>> };
    >>> In the function I wrote that takes struct param as a type I don't
    >>> know how to chose a type in the struct for void *. I have:
    >>>
    >>> fread(p.buf,1,sizeof p.buf,p.infile);

    >>
    >> You probably want buf to be array, not a pointer. This might be what
    >> you mean by the fact that you " don't know how to chose a type in the
    >> struct for void *". I suspect that means you don't know what type buf
    >> should have.
    >>
    >> If you don't want an array in the struct then the fread call is
    >> probably wrong. The count argument should be the number of
    >> characters that you want to read (size of p.buf is a small number
    >> like 4 or 8 -- it's the size of a pointer).
    >>
    >>> Is there no way to change a return type as declared in a struct's
    >>> elements ?

    >>
    >> I don't know what this means. Functions have a return type, but a
    >> struct's elements just has a type.
    >>
    >>> The elements are all of type struct param now.

    >>
    >> That does not make sense. Two are of type char * and one is of type
    >> void *.
    >>
    >>> Should I just leave the void * variable out of the struct and
    >>> declare it as a type char * or int * or size_t * whatever I want
    >>> later as I need
    >>> it?

    >>
    >> It's impossible to tell because you give no context. What is this
    >> struct for? It may be fine as it is of it could be all wrong.
    >> Without context is just three bit of data collected together for no
    >> apparent reason.
    >>
    >>> Is this clear?

    >>
    >> Not without more context.

    >
    > I suspect the author of fread and fwrite used the generic pointer type
    >for a reason. So you could change array types like for example char
    >buf[200]; or int buf [1000]; I usually use a size_t as the array type. But
    >putting the type void * in the prototype gives flexibility normally. But
    >what about in the struct? Do I need to change the type to int * or size_t *
    >for the array type. I don't know how to change it later to a int * or char *


    You have allowed the presence of the structure to completely obscure
    whatever the real topic of your question is. Your real question seems
    to be how to use fread and fwrite. Both functions require four pieces
    of information:

    1 - The address of a buffer. fread will store data obtained from
    the stream in this buffer. fwrite will copy the data from the buffer
    to the stream. No matter what type of address you provide, it will be
    converted to a void* if it has a different type. If you define the
    buffer as an array and use the array name as the argument, then you
    don't have to worry about the type since the array name will be
    automatically converted to the address of the first element with the
    correct type. If you dynamically allocate the buffer or otherwise
    designate its address in a pointer, then you would use the pointer as
    the argument. While neither fread nor fwrite care about the pointer
    type, when you attempt to access the elements of the buffer, it is
    your responsibility to make sure that the pointer is of the correct
    type.

    2 - The size of a single unit of data in the buffer. One
    possibility would be sizeof(int) if the buffer contains objects of
    type int.

    3 - The number of objects to be transferred to or from the
    buffer.

    4 - The address of a FILE object usually obtained from fopen().
    Neither fread nor fwrite take the file name as an argument as you
    coded in your original post.

    >Make Sense? If not I'll post some code.


    Since you tend to post code that has nothing to do with your question,
    you should include a verbal description of what it you intend to
    accomplish.

    --
    Remove del for email
     
    Barry Schwarz, Sep 14, 2012
    #4
  5. On Sep 14, 3:26 am, "Bill Cunningham" <> wrote:

    >     In fread/fwrite the first parameter takes a pointer to a void. The
    > generic pointer. I wrote a struct that would insert the in file name and out
    > file name through fopen.


    what does "through fopen" mean?


    > My struct looks like this.
    >
    > struct param {
    >     char *infile;
    >     char *outfile;
    >     void *buf;};


    looks ok

    > In the function I wrote that takes struct param as a type


    you mean "as a parameter" or "as an argument"

    > I don't know how
    > to chose a type in the struct for void *.


    I've no idea what this means. void* IS a type.

    > I have:
    >
    >    fread(p.buf,1,sizeof p.buf,p.infile);


    ok. But make sure buf is pointing to something. Where do you think
    fread(0 is going to put the data it reads?

    > Is there no way to change a return type as declared in a struct's elements ?


    no idea what this means. A structs elements do not declare a "return
    type"

    > The elements are all of type struct param now.


    what elements? The elements in struct param are certainly not of type
    struct param

    >     Should I just leave the void * variable out of the struct and declare it
    > as a type char * or int * or size_t * whatever I want later as I need it?


    no idea

    >     Is this clear?


    you're kidding, right?
     
    Nick Keighley, Sep 14, 2012
    #5
  6. On Fri, 14 Sep 2012 03:24:27 -0700 (PDT), Nick Keighley
    <> wrote:

    >On Sep 14, 3:26 am, "Bill Cunningham" <> wrote:
    >
    >>     In fread/fwrite the first parameter takes a pointer to a void. The
    >> generic pointer. I wrote a struct that would insert the in file name and out
    >> file name through fopen.

    >
    >what does "through fopen" mean?
    >
    >
    >> My struct looks like this.
    >>
    >> struct param {
    >>     char *infile;
    >>     char *outfile;
    >>     void *buf;};

    >
    >looks ok
    >
    >> In the function I wrote that takes struct param as a type

    >
    >you mean "as a parameter" or "as an argument"
    >
    >> I don't know how
    >> to chose a type in the struct for void *.

    >
    >I've no idea what this means. void* IS a type.
    >
    >> I have:
    >>
    >>    fread(p.buf,1,sizeof p.buf,p.infile);

    >
    >ok. But make sure buf is pointing to something. Where do you think
    >fread(0 is going to put the data it reads?


    I wonder what fread will do with a char* when it is expecting a FILE*
    as the fourth argument.


    --
    Remove del for email
     
    Barry Schwarz, Sep 14, 2012
    #6
  7. Barry Schwarz wrote:

    > I wonder what fread will do with a char* when it is expecting a FILE*
    > as the fourth argument.


    I didn't notice that error. It's not in my code either. I don't seem to
    be making myself clear. I will post some code later when I get the time. If
    that doesn't work I'll go from there.

    Bill
     
    Bill Cunningham, Sep 14, 2012
    #7
  8. Bill Cunningham

    Angel Guest

    On 2012-09-14, Bill Cunningham <> wrote:
    > In fread/fwrite the first parameter takes a pointer to a void. The
    > generic pointer. I wrote a struct that would insert the in file name and out
    > file name through fopen. My struct looks like this.
    >
    > struct param {
    > char *infile;
    > char *outfile;
    > void *buf;
    > };
    > In the function I wrote that takes struct param as a type I don't know how
    > to chose a type in the struct for void *. I have:
    >
    > fread(p.buf,1,sizeof p.buf,p.infile);
    >
    > Is there no way to change a return type as declared in a struct's elements ?
    > The elements are all of type struct param now.
    > Should I just leave the void * variable out of the struct and declare it
    > as a type char * or int * or size_t * whatever I want later as I need it?
    >
    > Is this clear?


    It's pretty clear that you have no idea what you're talking about or
    what you are doing, yes. You've asked about fread() and fwrite()
    several times now and you still don't seem to understand what these
    functions do. (As well as generic confusion about structures,
    functions, and return values.)

    fread() reads objects from a stream into memory. fwrite() writes
    objects from memory into a stream. In both cases, it is your job to
    provide the following information to the function:
    1. The location in memory to read from or write to.
    2. The size of one single object, in bytes.
    3. The number of objects to be read or written.
    4. The stream to read from or write to.

    The first argument of fread() and fwrite() is of type void* because
    these functions can be used to read or write any kind of object, hence
    you can pass any type of pointer to it. It's your duty to pass a
    pointer that matches with your needs. (If you are reading char objects,
    use a pointer to char. If you're writing structures, pass a pointer to
    a structure.)

    Here is a very simple example of a program that writes some structures
    to a file:


    #include <stdio.h>

    struct Person
    {
    char name[20];
    unsigned int age;
    };

    int main(void)
    {
    struct Person people[] = { { "John", 34u },
    { "Dick", 48u },
    { "Harry", 25u } };

    FILE *file = fopen("people.db", "wb");
    fwrite(people, sizeof (people[0]), 3, file);
    fclose(file);
    }


    --
    "C provides a programmer with more than enough rope to hang himself.
    C++ provides a firing squad, blindfold and last cigarette."
    - seen in comp.lang.c
     
    Angel, Sep 14, 2012
    #8
  9. Barry Schwarz wrote:
    > On Fri, 14 Sep 2012 03:24:27 -0700 (PDT), Nick Keighley
    > <> wrote:
    >
    >> On Sep 14, 3:26 am, "Bill Cunningham" <> wrote:
    >>
    >>> In fread/fwrite the first parameter takes a pointer to a void. The
    >>> generic pointer. I wrote a struct that would insert the in file
    >>> name and out file name through fopen.

    >>
    >> what does "through fopen" mean?
    >>
    >>
    >>> My struct looks like this.
    >>>
    >>> struct param {
    >>> char *infile;
    >>> char *outfile;
    >>> void *buf;};

    >>
    >> looks ok
    >>
    >>> In the function I wrote that takes struct param as a type

    >>
    >> you mean "as a parameter" or "as an argument"
    >>
    >>> I don't know how
    >>> to chose a type in the struct for void *.

    >>
    >> I've no idea what this means. void* IS a type.
    >>
    >>> I have:
    >>>
    >>> fread(p.buf,1,sizeof p.buf,p.infile);

    >>
    >> ok. But make sure buf is pointing to something. Where do you think
    >> fread(0 is going to put the data it reads?

    >
    > I wonder what fread will do with a char* when it is expecting a FILE*
    > as the fourth argument.


    #include <stdio.h>

    struct param {
    char *infile;
    char *outfile;
    void *buf;
    };

    #include "p.h"

    int copi(struct param p)
    {
    size_t nread, nwrite;
    FILE *in, *out;
    if ((in = fopen(p.infile, "rb")) == NULL) {
    perror("fopen 1");
    return 1;
    }
    if ((out = fopen(p.outfile, "wb")) == NULL) {
    perror("fopen 2");
    return 2;
    }
    do {
    nread = fread(p.buf, 1, sizeof p.buf, in);
    nwrite = fwrite(p.buf, 1, nread, out);
    }
    while (!feof(in));
    fclose(in);
    fclose(out);
    printf("%zu %zu\n", nread, nwrite);
    return 0;
    }

    My question concerns the generic pointer in the struct. It's the prototype
    for fread/fwrite in my copi function but what if I wanted a int * or char *
    how would I choose that in a file calling main? Say I want buf to be a
    size_t for example.

    Bill
     
    Bill Cunningham, Sep 14, 2012
    #9
  10. Angel wrote:
    > It's pretty clear that you have no idea what you're talking about or
    > what you are doing, yes. You've asked about fread() and fwrite()
    > several times now and you still don't seem to understand what these
    > functions do.


    [snip]

    I write successful code with fread and fwrite all the time.

    Bill
     
    Bill Cunningham, Sep 14, 2012
    #10
  11. "Bill Cunningham" <> writes:
    <snip>
    > #include <stdio.h>
    >
    > struct param {
    > char *infile;
    > char *outfile;
    > void *buf;
    > };
    >
    > #include "p.h"


    I wonder what's in here?

    > int copi(struct param p)
    > {
    > size_t nread, nwrite;
    > FILE *in, *out;
    > if ((in = fopen(p.infile, "rb")) == NULL) {
    > perror("fopen 1");
    > return 1;
    > }
    > if ((out = fopen(p.outfile, "wb")) == NULL) {
    > perror("fopen 2");
    > return 2;
    > }
    > do {
    > nread = fread(p.buf, 1, sizeof p.buf, in);


    That size if wrong. The code may well work, but that's not a sensible
    size to use.

    > nwrite = fwrite(p.buf, 1, nread, out);
    > }
    > while (!feof(in));
    > fclose(in);
    > fclose(out);
    > printf("%zu %zu\n", nread, nwrite);
    > return 0;
    > }
    >
    > My question concerns the generic pointer in the struct. It's the prototype
    > for fread/fwrite in my copi function but what if I wanted a int * or char *
    > how would I choose that in a file calling main? Say I want buf to be a
    > size_t for example.


    I read this about a dozen times and finally I think I worked it out.
    The trouble is that you ask how do so what you think is needed when
    that's not what's needed at all.

    I think you want a function that can read int one time and chars the
    next. Other times you might want it to read size_ts or even something
    else like doubles. To do that, you don't change the type of the buffer,
    you change the size of the data being read. But (and it's a big but)
    this only works if the data you are reading is in the right format.
    You've posted questions about reading various file formats in the past
    so I can't tell if reading the data using fread is appropriate or not.

    Of course, at some point you need the data to be in a C object of the
    right type. You might read one or more ints using fread into a generic
    buffer, but you need to process them as ints. That may be, ultimately
    what you are asking, but the answer to how you do that is not
    substantially different to the answer to the question "how do I write a
    program?".

    --
    Ben.
     
    Ben Bacarisse, Sep 14, 2012
    #11
  12. On Fri, 14 Sep 2012 14:41:02 -0400, "Bill Cunningham"
    <> wrote:

    >Barry Schwarz wrote:
    >
    >> I wonder what fread will do with a char* when it is expecting a FILE*
    >> as the fourth argument.

    >
    > I didn't notice that error. It's not in my code either. I don't seem to
    >be making myself clear. I will post some code later when I get the time. If
    >that doesn't work I'll go from there.


    You change your code at random so we have no idea what is in it now
    but it certainly was in the code you originally posted as shown below:

    >> struct param {
    >>     char *infile;
    >>     char *outfile;
    >>     void *buf;};


    >>    fread(p.buf,1,sizeof p.buf,p.infile);


    --
    Remove del for email
     
    Barry Schwarz, Sep 14, 2012
    #12
  13. On Fri, 14 Sep 2012 17:31:28 -0400, "Bill Cunningham"
    <> wrote:

    >Angel wrote:
    >> It's pretty clear that you have no idea what you're talking about or
    >> what you are doing, yes. You've asked about fread() and fwrite()
    >> several times now and you still don't seem to understand what these
    >> functions do.

    >
    >[snip]
    >
    >I write successful code with fread and fwrite all the time.


    Strange that you never post any of this successful code when asking a
    question. Or did I miss the smiley?

    --
    Remove del for email
     
    Barry Schwarz, Sep 14, 2012
    #13
  14. On Fri, 14 Sep 2012 17:29:00 -0400, "Bill Cunningham"
    <> wrote:

    snip unrelated quotes from previous messages

    >#include <stdio.h>
    >
    >struct param {
    > char *infile;
    > char *outfile;
    > void *buf;
    >};
    >
    >#include "p.h"
    >
    >int copi(struct param p)
    >{
    > size_t nread, nwrite;
    > FILE *in, *out;
    > if ((in = fopen(p.infile, "rb")) == NULL) {
    > perror("fopen 1");
    > return 1;
    > }
    > if ((out = fopen(p.outfile, "wb")) == NULL) {
    > perror("fopen 2");
    > return 2;
    > }
    > do {
    > nread = fread(p.buf, 1, sizeof p.buf, in);


    p.buf is a pointer, not an array. This code will cause the input data
    to be placed in the memory where p.buf points to. Unfortunately, it
    will read only sizeof(void*) bytes (usually 4 or 8). Your third
    argument should evaluate to the size of the area that p.buf points to.

    > nwrite = fwrite(p.buf, 1, nread, out);


    At some point, you should confirm that fread was successful. Depending
    on where the out stream resides, checking fwrite may also make sense.

    > }
    > while (!feof(in));


    This loop will never end if there is an error reading from in.

    > fclose(in);
    > fclose(out);
    > printf("%zu %zu\n", nread, nwrite);


    Of what significance is the amount of data processed by the last read
    and write? Why do you print only the results of the last iteration
    through the while loop?

    > return 0;
    >}
    >
    >My question concerns the generic pointer in the struct. It's the prototype
    >for fread/fwrite in my copi function but what if I wanted a int * or char *


    You should not have, and you didn't show, a prototype for fread or
    fwrite in your function. The prototype should always be obtained by
    including the stdio.h standard header.

    >how would I choose that in a file calling main? Say I want buf to be a


    What do you mean when you say a file is "calling main"? Only a
    function can call a function. The only exception is the initial call
    to main which is performed by the startup code.

    One more time - no matter what type of object pointer you code as the
    first argument in your call to fread, fread WILL ALWAYS RECEIVE A
    void*. When fread transfers the data to your buffer, it takes no
    notice of the type of data. It doesn't know and doesn't care about
    types. It is simply transferring bytes. The same is true for fwrite.

    If you attempt to access the data with something other than fwrite,
    then the type becomes important. Go back and read my comments on this
    in my 9/13 11:26PM post.

    If you have an array x (of any type such as int or char), then in the
    calling program you can simply assign the address of the array to
    p.buf with the statement
    p.buf = x;
    Then when you call fread, the data will be placed in the array. IT IS
    YOUR JOB to insure that the array x is the correct type for the data
    that is in the file. You do not need a separate int* or char*.

    >size_t for example.


    Make up your mind. Do you want buf to be an object that holds the
    data being read or a pointer to an area that will hold the data? Right
    now, buf is a pointer and can point to any object you would like. If
    you want buf to actually hold the data, then first you change the type
    of buf from void* to the correct data type (size_t in this case) and
    then you pass fread the address of this object with
    nread = fread(&p.buf, 1, sizeof p.buf, in);

    --
    Remove del for email
     
    Barry Schwarz, Sep 14, 2012
    #14
  15. Bill Cunningham

    Angel Guest

    On 2012-09-14, Bill Cunningham <> wrote:
    > Angel wrote:
    >> It's pretty clear that you have no idea what you're talking about or
    >> what you are doing, yes. You've asked about fread() and fwrite()
    >> several times now and you still don't seem to understand what these
    >> functions do.

    >
    > [snip]
    >
    > I write successful code with fread and fwrite all the time.


    Given your utter confusion about basic concepts just about every time
    you post here, I strongly doubt that. Last time you asked about them
    you didn't even know what their return code meant.

    But maybe I am mistaken. Try posting some actual code next time you ask
    a question, instead of some half-baked lines that wouldn't even compile.


    --
    "C provides a programmer with more than enough rope to hang himself.
    C++ provides a firing squad, blindfold and last cigarette."
    - seen in comp.lang.c
     
    Angel, Sep 14, 2012
    #15
  16. Bill Cunningham

    Kaz Kylheku Guest

    On 2012-09-14, Angel <> wrote:
    > On 2012-09-14, Bill Cunningham <> wrote:
    > It's pretty clear that you have no idea what you're talking about or


    That has been clear for pretty much the entire decade since Cunningham
    started posting to comp.lang.c. Someone posting under the name "Bill
    Cunningham:" evidently first appeared on July 4, 2002.

    Assuming it is even the same person posting under that name, the passage
    of ten years leaves him yet grappling with the same beginner issues.

    Some people who have university degrees now and working as developers
    were elementary school kids in 2002.

    The idiot regulars in this newsgroup keep responding to Cunningham, like
    predictable drones. (You know what they say about endlessly repeating the same
    action, expecting different results.)
     
    Kaz Kylheku, Sep 14, 2012
    #16
  17. Ben Bacarisse wrote:
    > "Bill Cunningham" <> writes:
    > <snip>
    >> #include <stdio.h>
    >>
    >> struct param {
    >> char *infile;
    >> char *outfile;
    >> void *buf;
    >> };
    >>
    >> #include "p.h"

    >
    > I wonder what's in here?


    The above.

    >
    >> int copi(struct param p)
    >> {
    >> size_t nread, nwrite;
    >> FILE *in, *out;
    >> if ((in = fopen(p.infile, "rb")) == NULL) {
    >> perror("fopen 1");
    >> return 1;
    >> }
    >> if ((out = fopen(p.outfile, "wb")) == NULL) {
    >> perror("fopen 2");
    >> return 2;
    >> }
    >> do {
    >> nread = fread(p.buf, 1, sizeof p.buf, in);

    >
    > That size if wrong. The code may well work, but that's not a sensible
    > size to use.


    OK

    >
    >> nwrite = fwrite(p.buf, 1, nread, out);
    >> }
    >> while (!feof(in));
    >> fclose(in);
    >> fclose(out);
    >> printf("%zu %zu\n", nread, nwrite);
    >> return 0;
    >> }
    >>
    >> My question concerns the generic pointer in the struct. It's the
    >> prototype for fread/fwrite in my copi function but what if I wanted
    >> a int * or char * how would I choose that in a file calling main?
    >> Say I want buf to be a size_t for example.

    >
    > I read this about a dozen times and finally I think I worked it out.
    > The trouble is that you ask how do so what you think is needed when
    > that's not what's needed at all.
    >
    > I think you want a function that can read int one time and chars the
    > next. Other times you might want it to read size_ts or even something
    > else like doubles.


    Yes! Yes! I hoped I could cross the usenet understanding barrier. This post
    is not directly related to the fread fwrite functions I just happened to use
    them so I can get used to them. Personally I like fgetc and fputc.

    To do that, you don't change the type of the
    > buffer, you change the size of the data being read. But (and it's a
    > big but) this only works if the data you are reading is in the right
    > format. You've posted questions about reading various file formats in
    > the past so I can't tell if reading the data using fread is
    > appropriate or not.


    I've been reading binary data. Jpeg format.

    > Of course, at some point you need the data to be in a C object of the
    > right type. You might read one or more ints using fread into a
    > generic buffer, but you need to process them as ints. That may be,
    > ultimately what you are asking, but the answer to how you do that is
    > not substantially different to the answer to the question "how do I
    > write a program?".


    True.

    Bill
     
    Bill Cunningham, Sep 15, 2012
    #17
  18. Angel wrote:
    > It's pretty clear that you have no idea what you're talking about or
    > what you are doing, yes. You've asked about fread() and fwrite()
    > several times now and you still don't seem to understand what these
    > functions do. (As well as generic confusion about structures,
    > functions, and return values.)
    >
    > fread() reads objects from a stream into memory. fwrite() writes
    > objects from memory into a stream. In both cases, it is your job to
    > provide the following information to the function:
    > 1. The location in memory to read from or write to.
    > 2. The size of one single object, in bytes.
    > 3. The number of objects to be read or written.
    > 4. The stream to read from or write to.
    >
    > The first argument of fread() and fwrite() is of type void* because
    > these functions can be used to read or write any kind of object, hence
    > you can pass any type of pointer to it. It's your duty to pass a
    > pointer that matches with your needs. (If you are reading char
    > objects, use a pointer to char. If you're writing structures, pass a
    > pointer to a structure.)
    >
    > Here is a very simple example of a program that writes some structures
    > to a file:
    >
    >
    > #include <stdio.h>
    >
    > struct Person
    > {
    > char name[20];
    > unsigned int age;
    > };
    >
    > int main(void)
    > {
    > struct Person people[] = { { "John", 34u },
    > { "Dick", 48u },
    > { "Harry", 25u } };
    >
    > FILE *file = fopen("people.db", "wb");
    > fwrite(people, sizeof (people[0]), 3, file);
    > fclose(file);
    > }


    This thread has nothing to do with fread or fwrite.

    Bill
     
    Bill Cunningham, Sep 15, 2012
    #18
  19. Bill Cunningham

    Angel Guest

    On 2012-09-14, William Ahern <william@wilbur.25thandClement.com> wrote:
    > Kaz Kylheku <> wrote:
    >> On 2012-09-14, Angel <> wrote:
    >> > On 2012-09-14, Bill Cunningham <> wrote:
    >> > It's pretty clear that you have no idea what you're talking about or

    >
    >> That has been clear for pretty much the entire decade since Cunningham
    >> started posting to comp.lang.c. Someone posting under the name "Bill
    >> Cunningham:" evidently first appeared on July 4, 2002.

    >
    > Bill explained long ago that he had a mental illness. It's not possible to
    > tell if he's really a troll. Mental illness is a pretty good cover story.
    > And 10+ years would make for an extraordinarily long troll, even if by
    > multiple persons.
    >
    > If people want to spend their time answering his questions, so be it. It's
    > not skin off your back.


    As trolls go, he's fairly benign. His questions are at least on topic,
    and even if he doesn't learn from the answers he's given, others might.
    As far as I can tell he has yet to throw a tantrum, and his posting
    volume is fairly low. I'd wish more trolls were like him.


    --
    "C provides a programmer with more than enough rope to hang himself.
    C++ provides a firing squad, blindfold and last cigarette."
    - seen in comp.lang.c
     
    Angel, Sep 15, 2012
    #19
  20. Ben Bacarisse wrote:

    > I read this about a dozen times and finally I think I worked it out.
    > The trouble is that you ask how do so what you think is needed when
    > that's not what's needed at all.
    >
    > I think you want a function that can read int one time and chars the
    > next. Other times you might want it to read size_ts or even something
    > else like doubles. To do that, you don't change the type of the
    > buffer, you change the size of the data being read.

    [snip]

    Problem solved. Thanks Much.

    Bill
     
    Bill Cunningham, Sep 15, 2012
    #20
    1. Advertising

Want to reply to this thread or ask your own question?

It takes just 2 minutes to sign up (and it's free!). Just click the sign up button to choose a username and then you can ask your own questions on the forum.
Similar Threads
  1. Chris Fogelklou
    Replies:
    36
    Views:
    1,391
    Chris Fogelklou
    Apr 20, 2004
  2. Fernan Bolando

    Pointer to struct or Struct parameters

    Fernan Bolando, Aug 7, 2004, in forum: C Programming
    Replies:
    6
    Views:
    381
    Fernan Bolando
    Aug 8, 2004
  3. beetle
    Replies:
    2
    Views:
    913
    beetle
    Jan 25, 2005
  4. Zero
    Replies:
    16
    Views:
    661
    Barry Schwarz
    Nov 19, 2005
  5. aleksa

    Struct pointer vs. struct array pointer

    aleksa, Feb 20, 2013, in forum: C Programming
    Replies:
    16
    Views:
    472
    Shao Miller
    Feb 20, 2013
Loading...

Share This Page