Obsluga plikow wyslanie uchwytu do funkcji

Ogolnie chce za pomoca funkcji do tego pliku "a.txt' wpisac "hello world" 10 razy . Niestety nie wiem jak mam przekazac do funkcji ten "uchwyt".

 
#include <iostream>

using namespace std;
void wpisz_do_pliku_a(string napis,ofstream plik) // Nie wiem jak przeslac do funkcji ten uchwyt do pliku, zeby moc na nim dzialac w funkcji.
{
    for(int i = 0 ; i < 10 ; i++)
    {
        plik<<napis[i]<< endl;
    }

}
int main()
{
    fstream plik;
    plik.open("a.txt", ios::in | ios::out);
    if (plik.good()=true)
    {
        cout << "udalo sie otworzyc plik" << endl;
    }
    else
    {
        cout << "Nie udalo sie otworzyc pliku" << endl;
    }
    string napis = "Hello world";
    wpisz_do_pliku_a(napis,plik);
    plik.close();
    return 0;
}

napis[i] tutaj odwołuje się do danego znaku w tym std::string-u.
http://www.cplusplus.com/reference/string/string/operator%5B%5D/

Jeżeli chcesz wysłać do tego pliku 10 razy napis hello world oddzielony endlinami, napisz funkcję tak:

 
void wpisz_do_pliku_a(const string& napis, ofstream& plik)
{
    for(int i = 0 ; i < 10 ; i++)
    {
        plik << napis << "\n";
    }
}

Ale całość możesz właściwie skrócić do tej formy:

#include <iostream>
#include <fstream>

using namespace std;
int main()
{
    ofstream plik("a.txt");
    if (plik.is_open()) {
        for (int i = 0; i < 10; i++)
            plik << "Hello World" << '\n';
        plik.close();
    } else 
        std::cout << "Blad";

    return 0;
}

Postscriptum:

 
if (plik.good()=true)

Korzystasz tu z operatora = zamiast ==. Operator = przypisuje wartość, operator == porównuje wartości.

W pierwszym argumencie co funkcja przyjmuje jest przesylany adres stringa , a w drugim zeby po prostu moc dzialac na tym pliku w funkcji musze wyslac do niej adres tego uchwytu i trybu ? (jezeli bym chcial tylko odczytac to bym musial tak zapisac ifstream& plik ? )

#include <iostream>
#include <string.h>
using namespace std;
void wpisz_do_pliku_a(const string& napis,ofstream& plik) 
{
    for(int i = 0 ; i < 10 ; i++)
    {
        plik << napis << "\n";         // Tutaj i tak mi wywala blad ;(
    }

}
int main()
{
    fstream plik;
    plik.open("a.txt", ios::in | ios::out);
    if (plik.good()=true)
    {
        cout << "udalo sie otworzyc plik" << endl;
    }
    else
    {
        cout << "Nie udalo sie otworzyc pliku" << endl;
    }
    string napis = "Hello world";
    wpisz_do_pliku_a(napis,plik);
    plik.close();
    return 0;
}

 

Raz dwa trzy:

1. Zaincluduj nagłówek <fstream.h>
2. Ponownie przypominam o tym, że sprawdzasz równość danej wartości za pomocą == a nie =. Więc zmień (plik.good()=true) na (plik.good()==true)
3. Do funkcji podajesz nie fstream tylko ofstream. Więc albo zamień tą cześć

fstream plik;
plik.open("a.txt", ios::in | ios::out);

na tą

ofstream plik("a.txt"); 

Albo zmień funkcję tak, by przyjmowała parametr fstream, tzn:

void wpisz_do_pliku_a(const string& napis, fstream& plik) 

Co do Twojego zapytania:

std::ifstream możesz użyć do wczytywania informacji z plików, (input file stream)
std::ofstream możesz użyć do zapisu informacji do plików, (output file stream)
std::fstream możesz użyć do obu tych rzeczy. (file stream)

1 .plik.open("a.txt", ios::in | ios::out); // A czy to nie znaczy ze ja moge na tym pliku robic dwie rzeczy na raz ? tzn odczytywac i zapisywac ?

wpisz_do_pliku("a.txt","Hello world",3); // Chodzi mi oto jak odebrac "a.txt" w funkcji ? Wczesniej po prostu wysylalem ten uchwyt(plik) a teraz bezposrednio nazwe pliku .

3. ofstream plik("a.txt"); czyli ten zapis jest rownoznaczy temu ?

 
ofstream plik;
plik.open("a.txt")

1. znaczy

void funkcja(const std::string &nazwaPliku)
{
    ...
    ofstream plik(nazwaPliku);
    ...
}

...

int main()
{
   ...
   funkcja("a.txt");
   ...
}

3. tak

wpisz_do_pliku("a.txt","Hello world",3); 

Jeżeli chcesz mieć taką funkcje, która przyjmuje jako pierwszy parametr ("a.txt") nazwe pliku, w drugim parametrze ("Hello world") nazwa komunikatu, i (z tego co się tylko domyślam) w trzecim parametrze to, ile razy chcesz wypisać ten komunikat, to możesz taką funkcję napisać tak:

 void wpisz_do_pliku(const std::string& filename, const std::string& text, int amount) {
    std::ofstream file(filename);
    if(file.is_open()) {
        for (int i = 0; i < amount; i++) {
            file << text << "\n";
        }
    }
}

Dlaczego w funkcji mam jeszcze raz dac ofstream file jak mam ja w mainie?
Niestety jak stworzylem ta funkcje to mi tworzy plik "a"

 
#include <iostream>
#include <fstream>
using namespace std;
void wpisz_do_pliku(const string& plik,const string& napis,unsigned int ile) 
    ofstream file("plik");
    for(int i = 0 ; i < ile ; i++)
    {
        file << napis << "\n";
    }

}
int main()
{
    ofstream plik("a.txt");

    wpisz_do_pliku("a.txt","Hello world",3);
    if (plik.good()==true)
    {
        cout << "udalo sie otworzyc plik" << endl;
    }
    else
    {
        cout << "Nie udalo sie otworzyc pliku" << endl;
    }

    plik.close();
    return 0;
}

@up

Dlaczego w funkcji mam jeszcze raz dac ofstream file jak mam ja w mainie?

W zależności od tego co chcesz osiągnąć... ta funkcja którą ostatnio napisałem jest raczej przeznaczona do jednorazowego użytku, bo za każdym razem tworzy nowy lokalny obiekt ofstream w funkcji, co jest bez sensu w przypadku, gdy chcesz z tym obiektem jeszcze coś zrobić. Dlatego do tego typu funkcji powinno się podawać referencje już wczytanego obiektu fstream/ofstream jeżeli chcesz ją wielokrotnie wykorzystać. Tą funkcje napisałem tylko dlatego, że kolega chciał wiedzieć jak taka funkcja może wyglądać.

Jednocześnie w Twoim programie jest inny problem - chcesz stworzyć dwa pliki ofstream, jeden w tej funkcji, drugi w main. To bez sensu, po prostu jak wczytujesz ofstream w main to w tamtej funkcji przekazuj nie nazwe pliku (bo nie chcesz znowu wczytywać tego pliku) tylko referencje.

A w tej funkcji którą powinieneś zmienić, jest jeszcze jeden błąd:

ofstream file("plik");

zamiast

ofstream file(plik);

Zrobic z wpisz_do_pliku przeciazona funkcje ktora zamiast argumentu plik przyjmuje obiekt ( reprezentujacy wyjsciowy strumien pikow).
Znacie moze jakams stronke (po polsku) gdzie jest to w miare przystepny sposob wytlumaczone ?

 
#include <iostream>
#include <fstream>
using namespace std;
void wpisz_do_pliku(fstream &plik,const string& napis,unsigned int ile)
{
    for(int i = 0 ; i < ile ; i++)
    {
        plik<<napis<<endl;
    }
}
int main()
{
    fstream plik;
    plik.open("a.txt",ios::out);
    wpisz_do_pliku(plik,"Hello world",3);
    plik.close();
    return 0;
}

.

Zamiast argumentu plik przyjmuje obiekt reprezentujący wyjściowy strumień plikowy (jak to mam rozumiec?).Jakby wtedy wygladal ten kod?

Właściwie to nie tyle co obiekt, a referencja do obiektu. Po prostu, przekazujesz do funkcji fstream& plik i masz do niej dostęp z funkcji. Nie ma tu żadnej filozofii.

Znacie moze jakams stronke (po polsku) gdzie jest to w miare przystepny sposob wytlumaczone ?

Znam, ale po angielsku. Lepiej naucz się angielskiego. Nie jest to moje czepianie się ani nic, nie traktuj tego w taki sposób - po prostu nie dasz rady jeżeli nie będziesz znał angielskiego a będziesz chciał programować. (chyba że programowanie masz tylko na zaliczenie - np w szkole, a programować w przyszłości nie będziesz).
Po polsku coś takiego znalazłem: http://cpp0x.pl/kursy/Kurs-C++/Obsluga-plikow/305
W przypadku podstaw w C++-sie zazwyczaj jest coś jest po polsku, ale jakość może czasami życzyć wiele do życzenia. W ostateczności jak będziesz chciał to możesz do mnie napisać jakbyś czegoś nie rozumiał. O ile mnie żaden moderator 4programmers nie pomści mnie jakimś piorunem bym Cię zostawił samego z tym problemem i byś się trochę pomęczył xD

Czyli co do pierwszego to powinienem zostawic tak jak jest ?