type: other

text:
Jugendamt/ASD - Praxissemester II in einem Frauenhaus | Masterarbeit, Hausarbeit, Bachelorarbeit veröffentlichen
 27 Seiten, Note: unbenotet
 S K Susanne Kitzing (Autor)
 Praktikumsbericht II - Frauenhaus
 1.1 Äußeres Umfeld
 1.2 Klientenkreis
 1.4 Aufgaben des Frauenhauses
 1.5 Ziele des Frauenhauses
 1.6 Arbeitsweise
 1.6.1 Kontaktaufnahme
 1.6.2 Sozialpädagogische Hilfsangebote
 1.6.3 Methodischer Ansatz
 2. Eigener Tätigkeitsbereich als Praktikantin
 2.1 Beschreibung der Klientengruppe
 2.2 Aufgabenbereich und eigene Arbeitsweise
 4. Kritische Auseinandersetzung mit meiner Tätigkeit im Frauenhaus
 Praktikumsbericht I - Jugendamt/ASD
 Der Allgemeine Soziale Dienst (ASD) des Jugendamtes D. besteht im engeren Sinne aus sieben weiblichen Mitarbeiterinnen, die jeweils einen Stadtteil von D. betreuen (auch Bereich “Hilfen zur Erziehung” im ASD genannt). Weiterhin gehören zu dieser Abteilung noch zwei Mitarbeiter der Jugendgerichtshilfe (ein Mann und eine Frau) sowie zwei Mitarbeiterinnen der wirtschaftlichen Jugendhilfe. Auch die Bereiche Pflegekinderwesen und
 Adoptionsvermittlung, jeweils mit einer Mitarbeiterin besetzt, sind dem ASD zuzurechnen. Die gesamte Abteilung umfaßt 15 Mitarbeiter (14 Frauen und ein Mann) inklusive Abteilungsleiterin und Sekretärin. Meine Anleiterin sollte eigentlich die Abteilungsleiterin des ASD sein. Diese war jedoch die längste Zeit meines Praktikums krank, daraufhin übernahm das ihre Vertreterin.
 Der Ablauf meines Praktikums sah wie folgt aus. Ich wechselte im Zwei-Wochen-Rhythmus zwischen den einzelnen “Stadtteilsozialarbeiterinnen”, die dann auch meine Anleitung übernahmen. Außerdem arbeitete ich auch zwei Wochen in der wirtschaftlichen Jugendhilfe und in der Jugendgerichtshilfe. Diese Bereiche gehören zwar ebenfalls zum gesamten ASD. Ich möchte sie jedoch in meinem Bericht weitestgehend ausklammern, da ich dort sozusagen nur “reingeschnuppert” habe. Deshalb werde ich mich zum größten Teil auf meine Arbeit bei den “Stadtteilsozialarbeiterinnen” beschränken.
 Der Allgemeine Soziale Dienst berät und betreut folgende Klientel: Kinder, Jugendliche, junge Volljährige sowie deren Familien (Eltern oder auch andere Angehörige). Die Gründe für den Kontakt zum Jugendamt ergeben sich für jeden einzelnen Klienten aus den verschiedensten Problemlagen heraus, von Schulbummelei über Erziehungsschwierigkeiten bis hin zu Mißhandlung.
 Des Weiteren beraten die Mitarbeiter auch Paare in Trennungs- oder Scheidungssituation, wenn es um Umgangs- oder Sorgerechtsregelungen geht. Diese Art der Beratungen haben seit der Änderung des Kindschaftsrechts 1998 stark zugenommen.
 Daraus ergibt sich, daß die Sozialarbeiter des ASD nicht nur mit den verschiedenartigsten Problemen, sondern auch mit sehr unterschiedlichem Klientel konfrontiert werden. In einer Mutter-Kind-Einrichtung haben die Mitarbeiter z.B. immer dieselbe Klientel in ähnlicher Notsituation (minderjährige Schwangere, die nicht mehr bei ihrer Familie leben können, bzw. Betreuung benötigen). Dagegen erscheint der ASD als eine Art “Sammelbecken” für die vielfältigsten Probleme, die in irgendeiner Weise mit den Bereichen “Familie” oder “Erziehung” zu tun haben.
 Die gesetzlichen Grundlagen bilden den Rahmen für die Arbeit im Jugendamt, so auch im ASD.
 Dazu gehören das SGB X (enthält Vorschriften für Verwaltungsverfahren, Bestimmungen zum Schutz der Sozialdaten und für die Zusammenarbeit zwischen den Leistungsträgern), das BGB (z.B. § 1666 Kindeswohlgefährdung) und das BSHG (bei Feststellung von geistiger Behinderung bei einem Kind und daraufhin folgender Beantragung des Grundanerkenntnisses beim Sozialamt) im Allgemeinen. Als Spezialgesetz für den ASD gilt das SGB XIII (KJHG), besonders die darin verankerten Hilfen zur Erziehung (§§ 27-35). Für die Jugendgerichtshilfe, die dem Bereich ASD angegliedert ist, gilt als Spezialgesetz das JGG.
 1.4 Aufgaben / Ziele des ASD
 Der ASD (Bereich Hilfen zur Erziehung) erfüllt sehr unterschiedliche Aufgaben. Die wohl häufigste Tätigkeit sind die Beratungsgespräche. Dazu gehören die Erstgespräche, allgemeine Beratungs- bzw. Informationsgespräche, Beratungen in Erziehungsfragen (§ 18) und auch Beratungen zum Thema Umgangs- und Sorgerecht (§ 17).
 Ein weiterer Punkt ist die Mitwirkung des einzelnen „Stadtteilsozialarbeiters“ an Verfahren des Familiengerichts.
 Wenn z.B. Regelungen zum Umgangs- und Sorgerecht getroffen werden sollen vor Gericht, dann muß die zuständige Sozialarbeiter im ASD eine Stellungnahme an das Familiengericht schreiben und die dafür notwendigen Gespräche mit der Familie im Jugendamt führen. Bei den folgenden Anhörungen und Verfahren am Gericht ist in vielen Fällen dann die Anwesenheit der betroffenen Sozialarbeiterin notwendig. Da diese im Vorfeld Gespräche mit den beteiligten Personen geführt hat und so mündlich zu einigen ungeklärten Fragen noch Stellung nehmen kann.
 Ein Knackpunkt in der Arbeit beim ASD ist die Vermittlung und Weiterverweisung an die entsprechenden Beratungsstellen oder an andere Ämter. Oft ergeben sich in den Beratungen Fragen, die die zuständige Bearbeiterin im ASD nicht klären kann (z.B. “Ich weiß nicht wie ich meine Kinder ernähren soll, mein Schuldenberg wächst mir über den Kopf.”). In solchen Fällen kann die Bearbeiterin zumindest an die zuständigen Stellen verweisen (Schuldnerberatung) bzw. gleich telefonisch für den Klienten einen Termin absprechen.
 Die Mitarbeiterinnen im ASD sind in zwei Arbeitsbereichen tätig, im Innendienst, wie oben beschrieben, sowie im Außendienst. Zum Außendienst gehören Hausbesuche, Hilfeplangespräche in den einzelnen Jugendhilfeeinrichtungen und die Termine beim Familiengericht.
 Ziel des ASD ist es, dem Klienten die Unterstützung zu geben , die er braucht, um sein Problem wieder selbst in den Griff zu bekommen (Hilfe zur Selbsthilfe). Oberste Priorität ist dabei, bei allen Handlungen durch die Sozialarbeiter, der Schutz des Kindeswohls.
 1.5 Arbeitsweise
 1.5.1 Kontaktaufnahme
 Die Kontaktaufnahme im ASD kann in zwei unterschiedlichen Formen erfolgen, einerseits als Komm-Struktur und andererseits als Aufsuchende-Struktur. Das bedeutet, die Klienten kommen zum Teil zu den Sprechzeiten oder vereinbarten Terminen in das Amt. Und zum anderen suchen die Mitarbeiter ihre Klienten auch zu Hause auf (Hausbesuche) bzw. gehen in andere Einrichtungen wie z.B. Kinderheime, um dort Gespräche durchzuführen und gleichzeitig das Umfeld besser kennenzulernen. Die Aufsuchende-Struktur ist gleichzusetzen mit dem Außendienst.
 Um optimal mit den Klienten arbeiten zu können, soll eine Vertrauensbasis im Kontakt zu ihnen geschaffen werden. Schließlich werden zwischen Klient und Sozialarbeiterin oft Probleme besprochen, die zum Teil weit in die Privatsphäre hineinreichen.
 Im Büro im Jugendamt ist dies jedoch nur schlecht möglich. Die Büroatmosphäre, Zeitmangel der Sozialarbeiter sowie die Scheu vor Behörden sprechen in den meisten Fällen dagegen. Aus diesen Gründen ist die Aufsuchende-Struktur ein wichtiger Bestandteil der Arbeit im ASD. Bei Besuchen zu Hause oder im Heim ist die Distanz zum Klienten auch etwas geringer als am Arbeitsplatz im ASD. Andererseits bedeutet so ein Besuch auch immer wieder ein Eingriff in die Privatsphäre. Denn die Sozialarbeiterin ist eine Fremde in der Wohnung oder im Heim, die nachfragt und kontrolliert und jetztendlich über eine Hilfegewährung entscheidet.
 1.5.2 Sozialpädagogische Hilfsangebote
 Zu den Hilfsangeboten vom Sozialen Dienst des Jugendamtes zählen in erster Linie die Hilfen zur Erziehung nach den §§ 27-35 KJHG. Darunter finden sich folgende Formen der Hilfe: Beratung in Erziehungsberatungsstellen, Sozialpädagogische Familienhilfe (SPFH), Erziehungsbeistandschaft, Tagesgruppe, Vollzeitpflege, Heimerziehung und soziale Gruppenarbeit (wie z.B. Sozialer Trainingskurs). Zusätzlich zu den Hilfen zur Erziehung gibt es auch noch andere Angebote, wie die institutionelle Beratung in Erziehungs- und Sorgerechtsfragen (§§ 17,18) sowie die Eingliederungshilfe für seelisch Behinderte nach § 35a KJHG.
 Oberster Grundsatz bei allen Hilfearten ist es, zum Wohl des Kindes oder Jugendlichen zu handeln. Das heißt, die Form der Hilfe, welche die Sozialarbeiterin vorschlägt, sollte sich möglichst immer an den Bedürfnissen und Wünschen des Kindes oder Jugendlichen orientieren.
 Insgesamt lassen sich die Hilfsangebote des ASD in drei Kategorien einteilen: familienunterstützende, familienergänzende und familienersetzende Maßnahmen. Zur Kategorie der familienunterstützenden Maßnahmen zählen die SPFH, die Erziehungsbeistandschaft sowie die Beratung in der Erziehungsberatungsstelle, da diese Formen innerhalb der Familie laufen und meistens mit der gesamten Familie passieren. Die Tagesgruppe ist eine familienergänzende Maßnahme, da sich das Kind nur einen Teil des Tages außerhalb des Elternhauses befindet, die Hilfe aber nur mit ihm passiert und nicht mit der gesamten Familie zu Hause.
 Zu den familienersetzenden Maßnahmen zählen die Heimerziehung und Vollzeitpflege in einer Pflegefamilie. Diese Hilfeformen solle „die Familie ersetzen“, inwieweit das möglich ist, sei dahingestellt.
 Der Trend geht dahin, soweit wie möglich ambulante Hilfen einzusetzen, also familienunterstützende- sowie familienergänzende Maßnahmen. Zum einen aus Kostengründen, aber auch um die Familie soweit wie möglich erhalten zu können.
 1.5.3 Methodischer Ansatz
 Im ASD wird nach der Methodik der Einzelfallhilfe, als klassische Methode der Sozialen Arbeit, gehandelt. Die soziale Gruppenarbeit spielt in diesem Bereich keine Rolle, sie wird nur von der Jugendgerichtshilfe in Form von sozialen Trainingskursen durchgeführt.
 Jeder einzelne Fall wird gesondert betrachtet und beurteilt. Dabei steht der Klient mit seinen individuellen Problemen und Nöten im Mittelpunkt. Kaum ein Fall gleicht dem anderen. Denn auch wenn zwei Klienten das gleiche Problem haben, bedeutet das nicht, dass die gleiche Hilfe für sie geeignet ist. Es gibt demnach kein Patentrezept für die Vorgehensweise in den einzelnen Fällen. Vielmehr muß sich die Sozialarbeiterin immer wieder auf neue Situationen und neue Klienten einstellen.
 s. Punkt 1.2 - Klientenkreis
 2.2 Eigene Arbeitsweise und Aufgabenbereich
 Mein Arbeitsauftrag im ASD war, oberflächlich gesehen, den einzelnen Sozialarbeiterinnen soviel Arbeit wie möglich abzunehmen, vor allem die Schreibarbeiten (Stellungnahmen für d. FG, Bescheide, Berichte, HP, Statistik, Teamberatungsprotokolle). Gleichzeitig habe ich aber auch immer mal wieder Arbeitsaufträge bekommen, die ich weitesgehend selbständig bearbeiten konnte.
 Dazu gehörten in erster Linie die Statistik, aber z.T. auch Hausbesuche und Beratungsgespräche.
 Inwieweit ich selbständig arbeiten konnte bzw. welche Aufgaben ich bekam, das hing immer von der Sozialarbeiterin ab, bei der ich zu diesem Zeitpunkt im Büro saß. Ich habe mich jedoch immer wieder darum bemüht, Arbeitsaufträge zu bekommen, wo ich selbständig arbeiten konnte.
 Wenn z.B. eine Mitarbeiterin krank war oder Urlaub hatte, bei der ich zwei Wochen im Büro saß, dann habe ich oft allein ihr Büro übernommen. In diesem Fall habe ich dann mit ihrer vertretenden Sozialarbeiterin zusammengearbeitet. Bei anstehenden schwierigen Beratungsgesprächen, wo im Vorfeld schon etwas gelaufen ist, habe ich die Vertretung dazugeholt. Denn in diesen Fällen wußte sie in der Regel über die Vorgänge bescheid. Wenn Klienten allgemein beraten werden wollten (z.B. zu Umgangs- und Sorgerecht, Erziehungsfragen u.ä.) bzw. das erste Mal da waren, dann habe ich alles allein durchgeführt. Zum Teil wurden auch oft per Telefon Infos bzw. Beratung zu allgemeinen Fragen gewünscht (z.B. ich habe mich von meinem Partner getrennt, welches Umgangsrecht hat er? u.s.w.). Diese Gespräche habe ich ebenfalls allein geführt.
 In der Zeit, wo die für mich zuständige Sozialarbeiterin da war, bin ich sozusagen mit ihr „mitgelaufen“. Das heißt, ich habe Beratungsgespräche mit ihr zusammen geführt bzw. war bei allen von ihr zu führenden Gesprächen (Beratungen, HP u.s.w.) dabei, außer es war vom Klienten ausdrücklich nicht erwünscht. Zusätzlich bin ich mitgefahren, wenn es um Angelegenheiten im Außendienst ging (Hausbesuche, Hospitation in Heimen u.s.w.)
 Zum überwiegenden Teil bestand meine Arbeit hier jedoch aus Verwaltungsaufgaben, wie Berichte, Bescheide schreiben und Akten anlegen.
 An dieser Stelle möchte ich den Fall von Sabine O. darstellen. Ich habe dieses Beispiel gewählt, da ich an diesem Fall aktiv beteiligt war und hier auch stückweise selbständig tätig sein konnte. An dieser Falldarstellung läßt sich am besten meine eigene Arbeitsweise sichtbar machen. Zudem hatte ich in diesem Fall die Möglichkeit die Entwicklung dieses Mädchens über einen längeren Zeitraum zu verfolgen.
 Sabine O. ist 1983 als drittes von sechs Kindern geboren. Sie ist mit ihren Geschwistern bei ihrer alleinerziehenden Mutter und deren wechselnden Lebenspartnern aufgewachsen. 1995 gab es große familiäre Probleme zu Hause, daraufhin entstand der Kontakt zum Jugendamt.
 Schließlich kam Sabines älterer Bruder in ein Kinderheim und Frau O. bekam für sich und ihre restlichen fünf Kinder eine Familienhelferin zur Unterstützung. Im Alter von 15 Jahren ist Sabine dann ebenfalls in ein Heim gekommen, aufgrund von starken Spannungen zwischen ihr und ihrer Mutter.
 Ein Jahr später ist sie zu ihrem damaligen Freund nach Halle abgehauen und hat dort einige Wochen gewohnt. Später kam sie dann schwanger nach D. zurück. Über das Jugendamt D. wurde Sabine schließlich im Mütterhaus D. untergebracht. Dort lernte ich Sabine im Sommer 2000 kennen, noch bevor sie im Oktober ihren Sohn Niklas bekam.
 Sabine ist oberflächlich gesehen ein nettes, freundliches, anpassungsfähiges und zugängliches Mädchen. Aber sie kann auch sehr raffiniert sein, wenn es darum geht ihren Willen durchzusetzen bzw. Regeln zu umgehen. Dann läßt sie sich Ausreden einfallen und „lügt wie gedruckt“. Und wenn man sie beim Lügen ertappt, hat sie neue Ausreden parat.
 Im April 2001 hat Sabine eine Außenwohnung bekommen, in der sie weiterhin stundenweise von einer Mitarbeiterin des Mütterhauses nachbetreut wurde. Anfangs lief diese Nachbetreuung auch ganz gut. Nach drei Monaten jedoch fing Sabine an zu ausgemachten Terminen mit der Betreuerin nicht zu erscheinen bzw. war zu abgesprochenen Terminen nicht zu Hause. So war eine weitere Nachbetreuung durch die Mitarbeiterin des Mütterhauses bald nicht mehr möglich. Es war jedoch angedacht gewesen, daß Sabine nahtlos von der Nachbetreuung durch das Mütterhaus in die Betreuung durch eine Familienhelferin des Jugendamtes übergeht. Dies sollte im Oktober ́01 erfolgen, sobald eine Familienhelferin frei wäre.
 Ende September wurde die Nachbetreuung durch das Mütterhaus beendet, da eine Zusammenarbeit nicht mehr möglich war. Die Betreuerin meldete dies im Jugendamt der zuständigen Sozialarbeiterin, Frau S.. Sie schätzte ein, daß Sabines häusliche Situation noch sehr instabil ist und sie noch Begleitung und Unterstützung braucht (im finanziellen Bereich, sowie bei der richtigen Pflege des Kindes). Das Problem lag zudem noch darin, daß Sabine auch öfter die Schule (BVJ) durch ständige Krankschreibungen bummelte, und so ihr Hauptschulabschluß gefährdet war.
 Daraufhin wurde Sabine in das Jugendamt bestellt, wo sie einen Antrag auf Hilfe zur Erziehung stellen sollte. Dieser sollte ihr dann in Form der Familienhilfe bewilligt werden. Doch sie reagierte nicht auf die schriftlichen Einladungen des Jugendamtes. Bei Hausbesuchen durch Frau S. öffnete Sabine nicht.
 Als die zuständige Sozialarbeiterin, Frau S., erfuhr, daß ich Sabine kenne, bat sie mich um Mithilfe. Meine Aufgabe bestand darin, bei Sabine einen Hausbesuch zu machen. Ich sollte ihr noch einmal die Familienhilfe nahe legen, mit ihr über ihre Probleme sprechen (besonders finanzielle), mir den Zustand der Wohnung ansehen und sie dazu bringen, daß sie in der folgenden Woche bei Frau S. im Jugendamt vorspricht.
 Das Gespräch bei Sabine zu Hause verlief sehr positiv. Zu Anfang sagte ich ihr gleich, daß ich dienstlich, als Vertreterin des Jugendamtes, und nicht privat da bin (da ich ihr in meinem Praktikum im Mütterhaus versprochen hatte, sie mal zu besuchen, wenn sie eine eigene Wohnung hat). So wollte ich die Rolle, in der ich mich nun befand, transparent machen und gleichzeitig Sabine meine Grenzen verdeutlichen. Denn meine Befürchtungen waren, daß sie mich sonst als Vertreterin des Jugendamtes nicht ernst nehmen würde.
 Praxiskolloqium
 Susanne Kitzing (Autor)
 9783638155168
 Jugendamt/ASD, Praxissemester, Frauenhaus, Praxiskolloqium
 Susanne Kitzing (Autor), 2002, Jugendamt/ASD - Praxissemester II in einem Frauenhaus, München, GRIN Verlag, https://www.grin.com/document/8581
 Sozialraumorientierte Arbeit im Jugen...
 Allgemeiner Sozialer Dienst (ASD). Ar...
 Die Bedeutung des Verlustes der Wohnu...


text:
c ++ - atgalinio ryšio funkcijos C ++ - ngn-wiki.ru
 C + +, kada ir kaip naudojate atgalinio ryšio funkciją?
 Norėčiau matyti paprastą atgalinio ryšio funkcijos rašymo pavyzdį.
 19 февр. nustatykite cpx 19 vasario mėn 2010-02-19 20:16 '10, 20:16, 2010-02-19 20:16
 Pastaba Dauguma atsakymų yra susiję su funkcijų rodikliais, kurie yra viena iš galimybių pasiekti atgalinio ryšio logiką C + +, bet šiandien, manau, nėra palankiausia.
 Kas yra skambučiai (?) Ir kodėl juos naudoti (!)
 Atgalinis ryšys yra skambinamas (žr. Toliau) metodas, priimtas pagal klasę arba funkciją, kuri naudojama nustatyti dabartinę logiką, priklausomai nuo šio atgalinio ryšio.
 Viena iš priežasčių, kodėl naudojatės „callbacks“, yra parašyti universalų kodą, kuris nepriklauso nuo vadinamosios funkcijos logikos ir gali būti pakartotinai naudojamas su skirtingais atsiliepimais.
 Daugelis standartinės algoritmo bibliotekos <algorithm> funkcijų naudoja „callbacks“. Pvz., for_each algoritmas kiekvienam elemento iteratorių elementui taiko vienodą atšaukimą:
 template<class InputIt, class UnaryFunction> UnaryFunction for_each(InputIt first, InputIt last, UnaryFunction f) { for (; first != last; ++first) { f(*first); } return f; }
 kuris gali būti naudojamas pirmiausia padidinti ir spausdinti vektorių, perduodant atitinkamus skambučius, pavyzdžiui:
 std::vector<double> v{ 1.0, 2.2, 4.0, 5.5, 7.2 }; double r = 4.0; std::for_each(v.begin(), v.end(), [ v) { v += r; }); std::for_each(v.begin(), v.end(), [](double v) { std::cout << v << " "; });
 kuri spausdina
 Kitas „callbacks“ naudojimas yra informuoti skambinančius asmenis apie tam tikrus įvykius, kurie suteikia tam tikrą statinio / kompiliavimo laiko lankstumą.
 Asmeniškai naudoju vietinę optimizavimo biblioteką, kurioje naudojami du skirtingi atsiliepimai:
 Pirmasis atšaukimas vadinamas, jei reikalinga funkcijų vertė ir gradientas, pagrįstas įvesties verčių vektoriu (loginis atšaukimas: funkcijos vertės nustatymas / gradiento gavimas).
 Antrasis atgalinis ryšys vadinamas vieną kartą kiekvienam algoritmo etapui ir gauna tam tikrą informaciją apie algoritmo konvergenciją (pranešimo atšaukimas).
 Taigi bibliotekos kūrėjas neatsako už tai, kas atsitinka su informacija, kuri programuotojui teikiama per atgalinio ryšio pranešimą, ir jam nereikia nerimauti, kaip faktiškai nustatyti funkcijų vertes, nes jas teikia loginis atšaukimas. Teisingas šių užduočių sprendimas yra bibliotekos naudotojo užduotis, o biblioteka tampa plati ir bendresnė.
 Be to, atšaukimai gali apimti dinaminį elgesį veikimo metu.
 Įsivaizduokite tam tikrą žaidimų variklio klasę, kuri turi funkciją, kuri veikia kiekvieną kartą, kai vartotojas paspaudžia klaviatūros mygtuką, ir funkcijų, valdančių jūsų žaidimų elgesį, rinkinį. Naudodami „callbacks“, galite (pakartotinai) nuspręsti, kokių veiksmų bus imtasi.
 void player_jump(); void player_crouch(); class game_core { std::array<void(*)(), total_num_keys> actions; // void key_pressed(unsigned key_id) { if(actions[key_id]) actions[key_id](); } // update keybind from menu void update_keybind(unsigned key_id, void(*new_action)()) { actions[key_id] = new_action; } };
 Čia funkcija „ key_pressed naudoja actions , išsaugotus actions norint gauti norimą elgesį, kai paspaudžiamas tam tikras klavišas. Jei žaidėjas nusprendžia pakeisti šuolio mygtuką, variklis gali sukelti
 game_core_instance.update_keybind(newly_selected_key, >
 ir, pakeisdami šį mygtuką kitą kartą žaidimo metu, pakeiskite skambučių elgesį į key_pressed (kuris vadina player_jump ).
 Kas vadinama C ++ (11)?
 Žr. „ C ++ Concepts“: skambinant į oficialų aprašymą.
 Atgalinio atšaukimo funkcija gali būti įgyvendinta keliais būdais C ++ (11), nes gali būti vadinami keli skirtingi dalykai:
 Funkcijų nuorodos (įskaitant nario funkcijų rodykles)
 objektai std::function
 Išraiška privaloma
 Funkcijų objektai (klasės su perkrautomis funkcijomis, skambučių operator() )
 * Pastaba: taip pat gali būti vadinamas rodyklė į duomenų elementus, tačiau funkcija visai neskambinama.
 Keletas svarbių būdų, kaip išsamiai parašyti skambučius.
 X.1 „Rašymas“ šiame įraše reiškia atgalinio ryšio tipo paskelbimo ir pavadinimo sintaksę.
 X.2 Skambinimas atgaliniu ryšiu reiškia sintaksę šiems objektams skambinti.
 X.3 „Naudojimas“ atgalinis ryšys - tai sintaksė, skirta argumentams perduoti funkcijai naudojant atgalinio ryšio funkciją.
 Pastaba Pradedant nuo C ++ 17, f(...) tipo skambutis gali būti parašytas kaip std::invoke(f,...) kuris taip pat apdoroja rodyklę į nario registrą.
 1. Funkciniai rodikliai
 Funkcijų rodyklė yra „paprasčiausias“ (visuotinumo, skaitomumo, galbūt blogiausio) tipo, kuris gali turėti atgalinį ryšį.
 Tegul yra paprasta funkcija:
 1.1 Rašymo funkcijos indeksas / tipo žymėjimas
 Nurodomas funkcijos rodyklės tipas
 return_type (*)(parameter_type_1, parameter_type_2, parameter_type_3) // ie a pointer to foo has the type: int (*)(int)
 kur atrodys rodyklės tipas prie pavadintos funkcijos
 return_type (* name) (parameter_type_1, parameter_type_2, parameter_type_3) // ie f_int_t is a type: function pointer taking one int argument, returning int typedef int (*f_int_t) (int); // foo_p is a pointer to function taking int returning int // initialized by pointer to function foo taking int returning int int (* foo_p)(int) = // can alternatively be written as f_int_t foo_p = >
 using deklaraciją galime šiek tiek geriau f_int_t , nes „ f_int_t taip pat gali būti parašytas taip:
 Kur (bent jau man) daugiau f_int_t kad f_int_t yra naujo tipo pseudonimas ir lengviau atpažinti funkcijų rodyklės tipą
 Ir funkcijų deklaracija, naudojant funkcijų žymeklio tipą, bus:
 // foobar having a callback argument named moo of type // pointer to function returning int taking int as its argument int foobar (int x, int (*moo)(int)); // if f_int is the function pointer typedef from above we can also write foobar as: int foobar (int x, f_int_t moo);
 1.2 Atgalinis ryšys
 Skambučio žymėjimas atitinka paprastą funkcijų skambučio sintaksę:
 int foobar (int x, int (*moo)(int)) { return x + moo(x); // function pointer moo called using argument x } // analog int foobar (int x, f_int_t moo) { return x + moo(x); // function pointer moo called using argument x }
 1.3 Atgalinio ryšio naudojimas ir suderinami tipai
 Atgalinio ryšio funkcija, kuri priima rodyklę į funkciją, gali būti vadinama funkcijų rodyklėmis.
 Naudojant funkciją, kuri priima funkcijų žymeklio atšaukimą, yra gana paprasta:
 int a = 5; int b = foobar(a, foo); // call foobar with pointer to foo as callback // can also be int b = foobar(a, // call foobar with pointer to foo as callback
 1.4 Pavyzdys
 Galite rašyti funkciją, kuri nepriklauso nuo to, kaip veikia atgalinio ryšio darbai:
 void tranform_every_int(int * v, unsigned n, int (*fp)(int)) { for (unsigned i = 0; i < n; ++i) { v[i] = fp(v[i]); } }
 jei įmanoma, gali būti
 int double_int(int x) { return 2*x; } int square_int(int x) { return x*x; }
 int a[5] = {1, 2, 3, 4, 5}; tranform_every_int( 5, double_int); // now a == {2, 4, 6, 8, 10}; tranform_every_int( 5, square_int); // now a == {4, 16, 36, 64, 100};
 2. Rodyklės nario funkcija
 Rodyklė nario funkcijai (kai kurioms C klasėms) yra specialus (ir dar sudėtingesnis) rodyklės tipas funkcijai, kurios veikimui reikalingas C tipo objektas.
 struct C { int y; int foo(int x) const { return x+y; } };
 2.1 Rodyklės rašymas nario funkcijai / tipo žymėjimui
 Rodyklė tam tikros T klasės nario funkcijos tipui žymima
 // can have more or less parameters return_type (T::*)(parameter_type_1, parameter_type_2, parameter_type_3) // ie a pointer to C::foo has the type int (C::*) (int)
 kur pavadinimo rodyklė nario funkcijai , kaip ir rodyklės funkcija, atrodys taip:
 return_type (T::* name) (parameter_type_1, parameter_type_2, parameter_type_3) // ie a type 'f_C_int' representing a pointer to member function of 'C' // taking int returning int is: typedef int (C::* f_C_int_t) (int x); // The type of C_foo_p is a pointer to member function of C taking int returning int // Its value is initialized by a pointer to foo of C int (C::* C_foo_p)(int) = // which can also be written using the typedef: f_C_int_t C_foo_p = >
 Pavyzdys: funkcijos, kuri priima rodyklę į nario funkcijų atšaukimą , deklaravimas kaip vienas iš argumentų:
 // C_foobar having an argument named moo of type pointer to member function of C // where the callback returns int taking int as its argument // also needs an object of type c int C_foobar (int x, C const int (C::*moo)(int)); // can equivalently declared using the typedef above: int C_foobar (int x, C const f_C_int_t moo);
 2.2 Atgalinis ryšys
 Rodyklė į nario funkciją C gali būti panaudota prieš C tipo objektą, naudojant elemento prieigos operaciją nukreiptoje rodyklėje. Pastaba: reikalingas laikiklis!
 int C_foobar (int x, C const int (C::*moo)(int)) { return x + (c.*moo)(x); // function pointer moo called for object c using argument x } // analog int C_foobar (int x, C const f_C_int_t moo) { return x + (c.*moo)(x); // function pointer moo called for object c using argument x }
 Pastaba: jei yra C rodyklė, sintaksė yra lygiavertė (kur C rodyklė turėtų būti nukreipta):
 int C_foobar_2 (int x, C const * c, int (C::*meow)(int)) { if (!c) return x; // function pointer meow called for object *c using argument x return x + ((*c).*meow)(x); } // or equivalent: int C_foobar_2 (int x, C const * c, int (C::*meow)(int)) { if (!c) return x; // function pointer meow called for object *c using argument x return x + (c->*meow)(x); }
 2.3 Atgalinio ryšio naudojimas ir suderinami tipai
 Atšaukimo funkcija, kuri priima rodyklę į T klasės nario funkciją, gali būti vadinama rodikliu į T klasės nario funkciją
 Naudojant funkciją, kuri gauna žymiklį į nario funkcijų atšaukimą, taip pat yra požymių funkcijos analogas:
 C my_c{2}; // aggregate initialization int a = 5; int b = C_foobar(a, my_c, // call C_foobar with pointer to foo as its callback
 3. std::function objects ( <functional> antraštė)
 std::function yra polimorfinė įvyniojimo funkcija, skirta saugoti, kopijuoti ar skambinti vadinamaisiais objektais.
 3.1 Objekto std::function / type ženklo rašymas
 std::function objekto, saugančio skambintą objektą, tipas atrodo taip:
 std::function<return_type(parameter_type_1, parameter_type_2, parameter_type_3)> // ie using the above function declaration of foo: std::function<int(int)> stdf_foo = // or C::foo: std::function<int(const C int)> stdf_C_foo = >
 3.2 Atgalinis ryšys
 Klasės std::function operator() kuris gali būti naudojamas norint remtis jūsų tikslu.
 int stdf_foobar (int x, std::function<int(int)> moo) { return x + moo(x); // std::function moo called } // or int stdf_C_foobar (int x, C const std::function<int(C const int)> moo) { return x + moo(c, x); // std::function moo called using c and x }
 3.3 Atgalinio ryšio naudojimas ir suderinami tipai
 std::function atšaukimas yra bendresnis nei funkcijų rodyklės arba nario funkcijos rodyklė, nes skirtingi tipai gali būti perduoti ir netiesiogiai konvertuojami į std::function objektą.
 3.3.1 Nuorodos į funkcijas ir nuorodas į narių funkcijas
 Funkcijų žymeklis
 int a = 2; int b = stdf_foobar(a, // b == 6 ( 2 + (2+2) )
 arba rodyklė nario funkcijai
 int a = 2; C my_c{7}; // aggregate initialization int b = stdf_C_foobar(a, c, // b == 11 == ( 2 + (7+2) )
 3.3.2 Lambda išraiškos
 Nenurodytas lambda išraiška gali būti saugomas std::function objekte:
 int a = 2; int c = 3; int b = stdf_foobar(a, [c](int x) -> int { return 7+c*x; }); // b == 15 == a + (7*c*a) == 2 + (7+3*2)
 3.3.3 std::bind išraiškos
 Galima perduoti std::bind išraišką. Pvz., Susiejant parametrus su funkcijų žymeklio skambučiu:
 int foo_2 (int x, int y) { return 9*x + y; } using std::placeholders::_1; int a = 2; int b = stdf_foobar(a, std::bind(foo_2, _1, 3)); // b == 23 == 2 + ( 9*2 + 3 ) int c = stdf_foobar(a, std::bind(foo_2, 5, _1)); // c == 49 == 2 + ( 9*5 + 2 )
 Kur taip pat galima prijungti objektus kaip objektą, norėdami paskambinti į nario funkcijas:
 int a = 2; C const my_c{7}; // aggregate initialization int b = stdf_foobar(a, std::bind( my_c, _1)); // b == 1 == 2 + ( 2 + 7 )
 3.3.4 Funkciniai objektai
 Klasių, turinčių tinkamą operator() perkrovą, objektai gali būti saugomi objekto std::function .
 struct Meow { int y = 0; Meow(int y_) : y(y_) {} int operator()(int x) { return y * x; } }; int a = 11; int b = stdf_foobar(a, Meow{8}); // b == 99 == 11 + ( 8 * 11 )
 3.4 Pavyzdys
 Pavyzdinio funkcijų rodyklės keitimas, norint naudoti std::function
 void stdf_tranform_every_int(int * v, unsigned n, std::function<int(int)> fp) { for (unsigned i = 0; i < n; ++i) { v[i] = fp(v[i]); } }
 suteikia daug daugiau naudos šiai funkcijai, nes (žr. 3.3) turime daugiau galimybių ją naudoti:
 // using function pointer still possible int a[5] = {1, 2, 3, 4, 5}; stdf_tranform_every_int( 5, double_int); // now a == {2, 4, 6, 8, 10}; // use it without having to write another function by using a lambda stdf_tranform_every_int( 5, [](int x) -> int { return x/2; }); // now a == {1, 2, 3, 4, 5}; again // use std::bind : int nine_x_and_y (int x, int y) { return 9*x + y; } using std::placeholders::_1; // calls nine_x_and_y for every int in a with y being 4 every time stdf_tranform_every_int( 5, std::bind(nine_x_and_y, _1, 4)); // now a == {13, 22, 31, 40, 49};
 4. Šablono atgalinio ryšio tipas
 Naudojant modelius, kodas, kuris skambina atgaline data, gali būti dar bendresnis nei naudojant std::function objektus.
 Atkreipkite dėmesį, kad šablonai yra kompiliavimo laiko ir kompiliavimo laiko polimorfizmo projektavimo priemonė. Jei dinaminis elgesys važiavimo metu turėtų būti pasiektas naudojant atšaukimus, šablonai padės, tačiau jie nesukels dinamikos važiavimo metu.
 4.1 Rašymas (tipo pavadinimas) ir skambučių atšaukimai
 Apibendrinimas, t.y. Šį std_ftransform_every_int kodą std_ftransform_every_int galima pasiekti dar labiau naudojant šablonus:
 template<class R, class T> void stdf_transform_every_int_templ(int * v, unsigned const n, std::function<R(T)> fp) { for (unsigned i = 0; i < n; ++i) { v[i] = fp(v[i]); } }
 su dar bendresne (ir taip pat paprasčiausiomis) atšaukimo tipo sintaksėmis, kuri yra paprastas, bendrasis išeinantis argumentas:
 template<class F> void transform_every_int_templ(int * v, unsigned const n, F f) { std::cout << "transform_every_int_templ<" << type_name<F>() << ">\n"; for (unsigned i = 0; i < n; ++i) { v[i] = f(v[i]); } }
 Pastaba: įtrauktas išvestis išspausdina tipo pavadinimą, atspausdintą F šablono tipui.
 Dažniausias vienarūšio diapazono transformacijos įgyvendinimas yra standartinės bibliotekos dalis, būtent std::transform , kuri taip pat yra kartotinių tipų šablonas.
 template<class InputIt, class OutputIt, class UnaryOperation> OutputIt transform(InputIt first1, InputIt last1, OutputIt d_first, UnaryOperation unary_op) { while (first1 != last1) { *d_first++ = unary_op(*first1++); } return d_first; }
 4.2 Pavyzdinių skambučių ir suderinamų tipų naudojimo pavyzdžiai
 Suderinami šablono atšaukimo metodo std::function stdf_transform_every_int_templ identiški pirmiau nurodytiems tipams (žr. 3.4).
 Tačiau, naudojant šablono versiją, naudojamas atšaukimo atgalinis parašas gali šiek tiek pasikeisti:
 // Let int foo (int x) { return 2+x; } int muh (int const { return 3+x; } int woof (int { x *= 4; return x; } int a[5] = {1, 2, 3, 4, 5}; stdf_transform_every_int_templ<int,int>( 5, // a == {3, 4, 5, 6, 7} stdf_transform_every_int_templ<int, int const 5, // a == {6, 7, 8, 9, 10} stdf_transform_every_int_templ<int, int 5, >
 Pastaba: std_ftransform_every_int (ne šablono versija; žr. Aukščiau) veikia su foo bet nenaudoja muh .
 // Let void print_int(int * p, unsigned const n) { bool f{ true }; for (unsigned i = 0; i < n; ++i) { std::cout << (f ? "" : " ") << p[i]; f = false; } std::cout << "\n"; }
 Paprastas šablono parametras transform_every_int_templ gali būti bet koks galimas prašomas tipas.
 int a[5] = { 1, 2, 3, 4, 5 }; print_int(a, 5); transform_every_int_templ( 5, foo); print_int(a, 5); transform_every_int_templ( 5, muh); print_int(a, 5); transform_every_int_templ( 5, woof); print_int(a, 5); transform_every_int_templ( 5, [](int x) -> int { return x + x + x; }); print_int(a, 5); transform_every_int_templ( 5, Meow{ 4 }); print_int(a, 5); using std::placeholders::_1; transform_every_int_templ( 5, std::bind(foo_2, _1, 3)); print_int(a, 5); transform_every_int_templ( 5, std::function<int(int)>{ print_int(a, 5);
 1 2 3 4 5 transform_every_int_templ <int(*)(int)> 3 4 5 6 7 transform_every_int_templ <int(*)(int 6 8 10 12 14 transform_every_int_templ <int (*)(int 9 11 13 15 17 transform_every_int_templ <main::{lambda(int)#1} > 27 33 39 45 51 transform_every_int_templ <Meow> 108 132 156 180 204 transform_every_int_templ <std::_Bind<int(*(std::_Placeholder<1>, int))(int, int)>> 975 1191 1407 1623 1839 transform_every_int_templ <std::function<int(int)>> 977 1193 1409 1625 1841
 type_name naudojamas type_name
 #include <type_traits> #include <typeinfo> #include <string> #include <memory> #include <cxxabi.h> template <class T> std::string type_name() { typedef typename std::remove_reference<T>::type TR; std::unique_ptr<char, void(*)(void*)> own (abi::__cxa_demangle(typeid(TR).name(), nullptr, nullptr, nullptr), std::free); std::string r = own != nullptr?own.get():typeid(TR).name(); if (std::is_const<TR>::value) r += " const"; if (std::is_volatile<TR>::value) r += " volatile"; if (std::is_lvalue_reference<T>::value) r += " else if (std::is_rvalue_reference<T>::value) r += " return r; }
 24 февр. Atsakymą Pixelchemist pateikė vasario 24 d. 2015-02-24 10:02 '15 at 10:02 am 2015-02-24 10:02
 Taip pat yra būdas C atšaukti: funkcijų rodyklės
 //Define a type for the callback signature, //it is not necessary, but makes life easier //Function pointer called CallbackType that takes a float //and returns an int typedef int (*CallbackType)(float); void DoWork(CallbackType callback) { float variable = 0.0f; //Do calculations //Call the callback with the variable, and retrieve the //result int result = callback(variable); //Do something with the result } int SomeCallback(float variable) { int result; //Interpret variable return result; } int main(int argc, char ** argv) { //Pass in SomeCallback to the DoWork DoWork( }
 Dabar, jei norite perduoti klasių metodus kaip atšaukimus, šių funkcijų rodiklių deklaracijose yra sudėtingesnės deklaracijos, pavyzdžiui:
 //Declaration: typedef int (ClassName::*CallbackType)(float); //This method performs work using an object instance void DoWorkObject(CallbackType callback) { //Class instance to invoke it through ClassName objectInstance; //Invocation int result = (objectInstance.*callback)(1.0f); } //This method performs work using an object pointer void DoWorkPointer(CallbackType callback) { //Class pointer to invoke it through ClassName * pointerInstance; //Invocation int result = (pointerInstance->*callback)(1.0f); } int main(int argc, char ** argv) { //Pass in SomeCallback to the DoWork DoWorkObject( DoWorkPointer( }
 19 февр. Atsakymą pateikė Ramon Zarazua B. 19 vasaris. 2010-02-19 22:06 '10 10:06 val. 2010-02-19 22:06
 Scott Meyers pateikia gerą pavyzdį:
 class GameCharacter; int defaultHealthCalc(const GameCharacter gc); class GameCharacter { public: typedef std::function<int (const GameCharacter HealthCalcFunc; explicit GameCharacter(HealthCalcFunc hcf = defaultHealthCalc) : healthFunc(hcf) { } int healthValue() const { return healthFunc(*this); } private: HealthCalcFunc healthFunc; };
 Manau, kad šis pavyzdys viską pasakoja.
 std::function<> yra „šiuolaikinis“ C ++ skambinimo būdas.
 19 февр. atsakymą pateikė Karl von Moor , vasario 19 d. 2010-02-19 20:23 '10, 20:23, 2010-02-19 20:23
 Atgalinio atšaukimo funkcija yra metodas, kuris perduodamas į paprogramę ir tam tikru momentu vadinamas paprogramiu, kuriam jis perduotas.
 Tai labai naudinga kuriant daugkartinio naudojimo programinę įrangą. Pvz., Daugelis operacinių sistemų API (pvz., „Windows API“) dažniausiai naudoja „callbacks“.
 Pvz., Jei norite dirbti su aplanke esančiais failais, galite paskambinti API funkcija, naudodami savo procedūrą, ir jūsų procedūra vykdoma vieną kartą kiekvienam failui nurodytame aplanke. Tai leidžia API būti labai lanksti.
 19 февр. atsakymą pateikė Reed Copsey vasario 19 d 2010-02-19 20:20 '10, 20:20, 2010-02-19 20:20
 Priimtas atsakymas yra labai naudingas ir gana išsamus. Tačiau OP nustato
 Norėčiau matyti paprastą pavyzdį, kaip parašyti atgalinio ryšio funkciją.
 Taigi, čia jūs esate, iš C ++ 11 turite std::function , todėl nereikia funkcijų rodyklių ir panašių medžiagų:
 #include <functional> #include <string> #include <iostream> void print_hashes(std::function<int (const std::string hash_calculator) { std::string strings_to_hash[] = {"you", "saved", "my", "day"}; for(auto s : strings_to_hash) std::cout << s << ":" << hash_calculator(s) << std::endl; } int main() { print_hashes( [](const std::string str) { int result = 0; for (int i = 0; i < str.length(); i++) result += pow(31, i) * str.at(i); return result; }); return 0; }
 Beje, šis pavyzdys yra kažkaip realus, nes norite paskambinti print_hashes funkcija skirtingais maišos funkcijų įgyvendinimais, tam tikslui pateikiau paprastą. Jis gauna eilutę, grąžina int (pateiktos eilutės maišos vertė), ir viskas, ką reikia prisiminti iš sintaksės yra std::function<int (const std::string> , kuri apibūdina tokią funkciją kaip įvestis funkcijos, kuri ją pavadins, argumentas.
 01 июля '16 в 23:36 2016-07-01 23:36 atsakymą pateikė Miljen Mikic liepos 1 d. 16 d. 23:36 2016-07-01 23:36
 C ++ sistemoje nėra aiškios atgalinio ryšio funkcijos koncepcijos. Atgalinio ryšio mechanizmai dažnai įgyvendinami naudojant funkcijų rodykles, funktorių objektus arba atgalinio ryšio objektus. Programuotojai turi aiškiai sukurti ir įdiegti atgalinio ryšio funkcijas.
 Pakeisti pagal atsiliepimus:
 Nepaisant neigiamų atsiliepimų, gautų atsakant, tai nėra. Bandysiu geriau paaiškinti, iš kur aš esu.
 „C“ ir „C ++“ turi viską, ko reikia, kad įdiegtumėte atgalinio ryšio funkcijas. Наиболее распространенным и тривиальным способом реализации функции обратного вызова является передача указателя функции в качестве аргумента функции.