FILE* as a public

Question

Once again I seek support here.

For example I have this fopen thing called fp

FILE * fp;

fp=fopen("Entity.dat","wb");

And I have x functions and there is need to use this thing in all of them, so the question is how can I make it public/global scope.

Don't. Pass it as a parameter, ideally after validating it as non-NULL. — WhozCraig, Apr 22 '13 at 16:13
Just because we smoke the same thing... If you cannot pass the file descriptor to the functions, you should be able to declare it in the header. But I don't see how just putting it outside of `main()` fails to do the trick. — Shark, Apr 22 '13 at 16:13
Why is this tagged `c++` if you are clearly working in `c` only? — StoryTeller - Unslander Monica, Apr 22 '13 at 16:13
Declare it outside the function scope in case of "C". But, I don't understand why can't you pass it as input to your x functions. — Jay, Apr 22 '13 at 16:13
Than bundle related operations and data in a class or a namespace. Besides, it seems like the variable only needs to be visible in a single or limited scope. — StoryTeller - Unslander Monica, Apr 22 '13 at 16:21
@undefined `Once again I seek support here.`.Well, 'Once again you get support here`. — Rüppell's Vulture, Apr 22 '13 at 16:28

score 7 · Answer 1 · answered Apr 22 '13 at 16:19

7

Ideally, you should simply pass it as a parameter to whatever functions need to use it:

void func( FILE *f, ... )
{
  // do something with f
}

int main( void )
{
  FILE *fp = fopen( "Entity.dat", "wb" );
  ...
  func( fp, ... );
  ...
}

answered Apr 22 '13 at 16:19

John Bode

119,563
19
122
198

score 4 · Accepted Answer · answered Apr 22 '13 at 16:13

4

You should use extern:

the_file.h

#ifndef FILE_H
#define FILE_H

...

extern FILE *file;

#endif

the_file.cpp

#include "file.h"

FILE *file;

Then open the file and store the handle in file. Next, you can use file where do you need.

answered Apr 22 '13 at 16:13

masoud

55,379
16
141
208

Open the file and assign the handle to `file' inside main() or any other function?Can u clarify a little? – Rüppell's Vulture Apr 22 '13 at 16:26
It depends on the programer to decide, for example he can open it first in then main. – masoud Apr 22 '13 at 16:31

score -1 · Answer 3 · edited May 23 '17 at 12:28

If you have a choice, please pass it as a parameter, if you really really don't have any choice, then you could consider about singleton.

c++11

template<typename T>
class meyersSingleton
{
public:
  static T& instance()
  {
    static T theSingleton;
    return theSingleton;
  }

  meyersSingleton() = delete;
  ~meyersSingleton() = delete;
  meyersSingleton(meyersSingleton const&) = delete;
  meyersSingleton& operator=(meyersSingleton const&) = delete;

};

c++98

template<typename T>
class meyersSingleton
{
public:
  static T& instance()
  {
    static T theSingleton;
    return theSingleton;
  }

private :
  meyersSingleton();
  ~meyersSingleton();
  meyersSingleton(meyersSingleton const&);
  meyersSingleton& operator=(meyersSingleton const&);

};

you could use it as this way

#include <cstdio>

template<typename T>
class meyersSingleton
{
public:
  static T& instance()
  {
    static T theSingleton;
    return theSingleton;
  }

  meyersSingleton() = delete;
  ~meyersSingleton() = delete;
  meyersSingleton(meyersSingleton const&) = delete;
  meyersSingleton& operator=(meyersSingleton const&) = delete;

};

void read_file()
{
    char buffer [100];
    fgets (buffer , 100 , meyersSingleton<FILE*>::instance());
    printf("%s", buffer);    
}

int main()
{             
    FILE **a = &meyersSingleton<FILE*>::instance();
    *a = fopen("coeff", "rb");

    read_file();   

    return 0;
}

not a very intuitive solution, but it will guarantee you only have a global and single FILE.

If you need more single FILE, you could add one more template parameter

template<typename T, size_t N = 0>
class meyersSingleton
{
public:
  static T& instance()
  {
    static T theSingleton;
    return theSingleton;
  }

  meyersSingleton() = delete;
  ~meyersSingleton() = delete;
  meyersSingleton(meyersSingleton const&) = delete;
  meyersSingleton& operator=(meyersSingleton const&) = delete;

};

If you are using c, then just omit this solution.

Edit : In most of the cases, singleton considered as a bad solution, an anti-pattern which should no be used and leave it alone.Here are some good articles discussing about the pros and cons of singleton.

why singleton is so bad Singleton I love you, but you're bringing me down

Don't take me wrong, singleton do solve one problem--it guarantee you will only have one object(variable, resource, whatever) at a time, sometimes this is very useful(although it is rare).Log is an example, we need log everywhere, and the log wouldn't write something into our program.

I get it's not the best answer, but what's with the down votes? What happened to preferring commenting and editing over down voting? — StoryTeller - Unslander Monica, Apr 22 '13 at 16:25
But seriously, @SteroMatching, you have to explain how using a singleton solves the OP's problem, instead of just saying how to implement a singleton. — StoryTeller - Unslander Monica, Apr 22 '13 at 16:27
-1: Singletons are rarely needed, often abused, and in this case they add complexity for no benefit. I don't believe it is a good idea to point a beginner towards inappropriate solutions. The only suggestion I can make to improve the answer is to remove it (an alternative would be to extend it to explain why a singleton isn't a good choice here, but that would be well outside the scope of the original question). — John Bartholomew, Apr 22 '13 at 19:05

FILE* as a public

3 Answers3