myOWNsystem
Anmeldungsdatum: 24. Dezember 2020
Beiträge: Zähle...
|
Hallo,
ein schwieriges Thema... Ich habe mich in letzter zeit sehr viel mit Linux und Bash beschäftigt. Ich muss ehrlich sagen: Dieses Betriebssystem ist besser als Windows 😉. Ich habe schon seit langer zeit mit Windows Batch beschäftigt und verstehe es super. Als ich dann aus Neugier zu Linux gewechselt bin war das erste was ich in das Terminal eingegeben habe: echo "Schöner Tag heute." Ich war sehr verwundert, dass es wirklich funktioniert hat. Also habe ich mich ran gesetzt und "gelernt". Dank dem guten Wiki hier in Ubuntuusers war das auch kein Problem. Jetzt möchte ich aber auch Grafische Programme erstellen. Ich habe auch etwas größere Erfahrung mit Programmieren, aber das ist schon ein größeres Projekt.
Linux nutzt meines Wissens C, oder?
Wie soll ich jetzt anfangen?
Mit welchen Programmen?
Habt ihr Tipps? Danke für eure mithilfe!
|
DJKUhpisse
Supporter, Wikiteam
Anmeldungsdatum: 18. Oktober 2016
Beiträge: 17647
Wohnort: in deinem Browser, hier auf dem Bildschirm
|
Du kannst da verschiedenste Programmiersprachen nutzen, C geht, Python geht, Java geht...
|
Axel-Erfurt
Anmeldungsdatum: 18. Mai 2016
Beiträge: 1347
|
|
noisefloor
Ehemaliger
Anmeldungsdatum: 6. Juni 2006
Beiträge: 29039
Wohnort: WW
|
Hallo,
Linux nutzt meines Wissens C, oder?
Ja, der Linux-Kernel ist in C geschrieben - aber das ist für dein Anliegen völlig egal. Wenn du ein Programm mit grafischer Oberfläche schreibst, macht man das i.d.R. mit Hilfe einer Bibliothek, die die passende Dinge wie Menüs, Eingabefelder etc. bereit stellt. Die "großen" / gängigen Bibliotheken sind GTK und Qt. GTK ist im C geschrieben, Qt in C++. ABER: es gibt reichlich Bindings für beiden Bibliotheken für andere Sprache wie z.B. Python. Aber auch vieles anderes, was gängig ist. Für GTK gibt es z.B. auch Vala, was speziell für GObject/GTK entwickelt wurde. Du hast also die Qual der Wahl ☺ Gruß, noisefloor
|
user_unknown
Anmeldungsdatum: 10. August 2005
Beiträge: 17552
Wohnort: Berlin
|
Es gibt fast jede Programmiersprache für Linux, nur sehr proprietäre Sprachen nicht. Da gibt es aber dann oft Klone bzw. Teilimplementierungen. Etwa Dot-Net von MS, da wurde lange versucht etwas kompatibles zu schaffen, aber gerade was die GUI-Programmierung betrifft gab es lange Schwierigkeiten, habe mich aber nicht näher damit beschäftigt. Ich bin nicht zu Linux gewechselt, um dann da MS-Produkte zu benutzen. Für simple Programme, die einem eine Liste im Fenster anzeigen, oder einen Auswahldialog, gibt es ein paar Sprachen, mit denen man aber auch schnell an Grenzen stößt, zenity ist eines davon, aber es gibt noch 2, 3 andere. Javaprogramme schreibt man plattformneutral mit Swing. Bei anderen Sprachen wurden QT und GTK schon genannt.
|
tom111
Anmeldungsdatum: 10. Juli 2020
Beiträge: 102
|
Sehe zwar das die Anfrage als gelöst eingestellt ist, hätte aber hierzu noch eine nützliche Info. Und zwar sozusagen von Anfänger zu Anfänger. Denn auch ich habe vor kurzem vor der selben Frage gestanden und musste erst einmal ein paar Grundlegende Informationen einsammeln um überhaupt einen Überblick zu bekommen, wie und womit man in Linux programmiert. Da ich auch Anfänger bin, kann ich es sehr gut nachvollziehen und möchte dir GTK ans Herz legen. Warum? Da brauchst du dich nicht erst in eine Entwicklungsumgebung einzuarbeiten, sondern kannst mit einem Texteditor gleich anfangen und dein Programm mit GCC im Terminal kompilieren. Ist alles bereits in Ubuntu vorhanden! Ja, natürlich muss man sich auch erst einmal damit beschäftigen, wie GTK aufgebaut ist und wie man es verwenden kann. Aber nach ca. 4 Wochen lernen, bin ich schon in der Lage meine alten Windowsprogramme auch unter Linux nachzubauen. UND! Mit GTK zu programmieren macht zumindest mir wirklich richtigen Spaß! 😎 Also ich kann GTK nur bestens für den Start empfehlen. Du solltest jetzt aber nicht denken, das GTK etwas sei, was den Anforderungen nicht nach kommen würde. GTK finde ich zumindest genauso leistungsfähig wie QT auch.
Gruß Tom
|
myOWNsystem
(Themenstarter)
Anmeldungsdatum: 24. Dezember 2020
Beiträge: 39
|
Danke für all eure Tipps! Linux nutzt meines Wissens C, oder?
Ja, der Linux-Kernel ist in C geschrieben - aber das ist für dein Anliegen völlig egal.
Ja, das merke ich auch gerade. 😉 Ich weiß nicht wieso ich das gefragt habe. 🤣
Da ich auch Anfänger bin, kann ich es sehr gut nachvollziehen und möchte dir GTK ans Herz legen. Warum?
Danke! Ich werde mich gleich morgen dran machen. Hört sich wirklich toll an. Freu mich schon. Also, schöne Tage noch und noch ein frohes schaffen!
|
ChickenLipsRfun2eat
Anmeldungsdatum: 6. Dezember 2009
Beiträge: 12067
|
tom111 schrieb: …Da brauchst du dich nicht erst in eine Entwicklungsumgebung einzuarbeiten…
Musst du bei Qt auch nicht. Es ist lediglich bequemer den Qt Creator zu verwenden. Genauso wie glade und/oder gnome-builder für GTK. Aber du hast unter Linux natürlich die freie Wahl des Editors — solange es Emacs ist 😀
|
Axel-Erfurt
Anmeldungsdatum: 18. Mai 2016
Beiträge: 1347
|
noisefloor schrieb:
Für GTK gibt es z.B. auch Vala, was speziell für GObject/GTK entwickelt wurde. dazu noch valaDevelop
|
tom111
Anmeldungsdatum: 10. Juli 2020
Beiträge: 102
|
Hallo nochmal... Möchte noch eine Info abgeben, die mir als blutiger Anfänger bei GTK gefehlt hatte. Das Forum hier bei den Ubuntuusers ist wirklich sehr gut und man hat auch mir schon sehr viel geholfen. Aber als Anfänger kennt man GTK noch überhaupt nicht und weiß damit auch noch nichts anzufangen. Wenn dann eine Information kommt wie z.B. die von Axel-Erfurt schrieb: noisefloor schrieb:
Für GTK gibt es z.B. auch Vala, was speziell für GObject/GTK entwickelt wurde. dazu noch valaDevelop
Damit kann man als blutiger Anfänger nicht wirklich etwas anfangen und man geht auf die Reise sich Vala anzusehen... Was natürlich später, wenn man sich erst einmal mit GTK richtig vertraut gemacht hat und GTK auch richtig kennengelernt hat, natürlich von Vorteil sein kann. GTK kann man letztendlich in vielen anderen Sprachen verwenden. So z.B. auch in Python und anderen mehr. Es geht aber genau so gut auch direkt anzuwenden ohne die Verwendung einer anderen Sprache. Nämlich ganz einfach mit einem Texteditor! Der Texteditor der in Ubuntu bereits vorhanden ist, (Icon = Blatt mit Bleistift darauf) kann auch schon einiges. Tippe einfach mal etwas C-haftes in diesen ein. Dann siehst du alle Buchstaben schwarz. Dann speichere das eingetippte unter z.B. test.c ab und du wirst sehen, das sich die Textfarbe ändert. Dass hilft schon mal für den Anfang! Wenn es dann mehr sein soll dann kann man Emacs verwenden wie es ChickenLipsRfun2eat geschrieben hat. Aber nun eine Info zu GTK die einem als blutiger Anfänger hilfreich sein sollte.
GTK kannst du sehen wie eine Kiste mit vielen Legosteinen. Hoffe ich bekomme jetzt kein Problem mit der Verwendung des Namens Lego! 🙄 Also jeder L-Stein ist eine GTK Anweisung, Methode oder wie man es auch immer bezeichnen möchte. Z.B. gtk_button_new_with_label("MEIN BUTTON");. Das wäre dann ein L-Stein der einen Button entspricht. Wo du diesen dann ansteckst, das ist dann deiner Ideen überlassen. Du kannst wie bei den L-Steinen das bauen, was du möchtest. Du musst "nur"!!! wissen, welchen L-Stein du für was benötigst und dann den entsprechenden Stein auf die anderen setzen, bis du dein Projekt fertig hast. Auch sehr wichtig ist zu wissen, das GTK auf eine Baumstruktur aufbaut. Das bedeutet, erst kommt der dicke Baumstamm, dann die ersten dicken Äste und dann die kleineren Äste und zum Schluss die Blätter. Auf der Gnome/GTK Seite gibt es ein Beispiel C-Code für das erste Programm. Dieses finde ich nicht ganz so toll als "Startprogramm" weil es auf das absolut notwendigste reduziert ist. Das bringt dann mehr Frust als Lust, wenn man darin versucht die Größe eines Widgets zu ändern oder noch ein weiteres Widget darin einzufügen. Weil das klappt nicht und bringt nur Fehlermeldungen mit denen man noch nichts anfangen kann! Denn der dicke Baumstamm ist das Hauptfenster gtk_window_new(); und in dieses kann man nur 1 ich betone nochmals EIN! Widget einsetzen und nicht mehr! Um aus dem Baumstamm die ersten dicken Äste herauswachsen zu lassen benötigt man dann L-Steine die in GTK Container genannt werden. Auch die Container sind Widgets so wie man alle "L-Steine" von GTK bezeichnet. Container stellen die Möglichkeit zur Verfügung, weitere Äste aus dem "Elternbaumstamm" herauswachsen zu lassen. Also weitere Widgets darin platziert zu bekommen. Das können dann wiederum weitere Container sein, die weitere kleinere Äste aus einem Nebentrieb herauswachsen lassen, oder auch schon Blätter wie Buttons, Labels, Entrys usw. Ich denke wenn man erst einmal diese Strucktur von GTK verinnerlicht hat, ist es eine Freude mit GTK zu arbeiten. Auch ohne die Verwendung einer anderen Sprache. Der Name "Glade" ist auch schon gefallen. Was ist aber Glade? Das ist ein Programm womit man das Design seiner Programmoberfläche sehr einfach mit einer graphischen Oberfläche erstellen kann. Am Anfang habe ich es auch dazu verwendet. Mein Ansporn war es aber zu lernen wie, die graphische Oberfläche meines Programms direkt im Texteditor mit den entsprechenden GTK-"Bausteinen" zu erstellen geht. ABER! Glade kann man sehr gut auch dazu verwenden, sich mit den möglichen Widgets erst einmal vertraut zu machen und zu sehen, was kann man alles damit anstellen. Denn in Glade kann man sein Programm bereits als Simulation laufen lassen! So, das sollte jetzt aber erst einmal reichen, damit man einen guten Start als blutiger Anfänger in GTK bekommen kann. Natürlich muss man sich mit all den L-Bausteinen erst einmal vertraut machen. Lernen was gibt es da alles und lernen wie man diese mit entsprechenden Werten, Texten, usw. bestückt. Ich habe z.B. mir ein Testprogramm geschrieben, was das Hauptfenster enthält, was einen Container enthält worin ein Button, ein Label und ein Entry eingesetzt sind. Das reicht dann erst einmal, um die wichtigsten Widgets darin nacheinander einzufügen und daran forschen was alles möglich ist. Habe mir dann zu jedem der wichtigen Widgets eine separate Datei angelegt mit zusätzlichen Informationen. Also wie eine Art Datenbank, worauf ich auch noch später zurückgreifen kann. Hoffe das Ganze hier hilft dir jetzt erst einmal um den Einstieg leicht zu finden.
Gruß Tom.
|
tom111
Anmeldungsdatum: 10. Juli 2020
Beiträge: 102
|
Hallo und Ahoi. Da ich ja das "Startprogramm" von der Gnome/GTK Seite kritisiert hatte und die Infos letztendlich ja doch nur Theorie sind, stelle ich hier mal ein anderes "Startprogramm" mal ein. Das ist dann halt mal richtige Praxis, da ich auch viele Kommentare dazu eingetragen habe. Dieses Listing kann man herauskopieren, in den Texteditor eingeben und unter main.c in sein HOME Verzeichnis abspeichern. 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107 | //Programm Beispiel in C welches nur die reinen GTK+ Befehle und nicht GLADE verwendet!
//
//Made By me
//
//Den folgenden String komplett kopieren und im Terminal einfügen, um das erstellte Programm zu kompilieren:
//gcc $(pkg-config --cflags gtk+-3.0) -rdynamic -o test main.c $(pkg-config --libs gtk+-3.0)
//Nach der Kompilierung, wenn es keine Fehlermeldungen gab, im Terminal folgendes zum starten des Programms eingeben und sich freuen... :-)
//./test
//=================================================================
//Dringende und/oder häufig benötigte Libraries (Bibliotheken) hinzufügen
//=================================================================
//Diese verwendeten kann man immer angeben, da meistens für "normalen" C-Code benötigt. GTK sowieso immer!
#include <gtk/gtk.h>
#include <stdlib.h>
#include <stdio.h>
//=================================================================
//Zeiger auf alle verwendeten Widgets setzen
//=================================================================
//Zeiger auf die einzelnen Widgets festlegen (Werden mehrere Widgets des selben Typs implementiert, so ist es das Beste, wenn man diese mit einer Zahl auseinander hält!
GtkWidget *window; //Pointer auf das Hauptfenster (Baumstamm) erstellen
GtkWidget *fixed; //Pointer auf den Container (erste dicke Äste) für die Platzierung der weiteren Widgets.
GtkWidget *button1; //Pointer auf den Button 1 erstellen (ein Blatt)
GtkWidget *text_entry; //Pointer auf ein Entry zur Anzeige von Textdaten machen (ein Blatt)
//=================================================================
//Alle SIGNAL-Funktionen deklarieren (Die "Unterprogramme")
//=================================================================
//Funktion die angewendet wird, wenn das Programm geschlossen wird
void exit_programm (GtkButton *button, gpointer data);
//Funktion wenn der Button 1 geklickt wurde.
void button1_clicked (GtkButton *button, gpointer data);
//=================================================================
//DIE MAIN!
//=================================================================
int main (int argc, char *argv[])
{
//GTK+ initialisieren
gtk_init (&argc, &argv);
//Hauptfenster (Baumstamm) erstellen, Titel setzen, Rahmenabstand setzen
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
//Titel für das Hauptfenster setzen
gtk_window_set_title (GTK_WINDOW (window), "Testprogramm");
//Den Rand des Hauptfensters einstellen
gtk_container_set_border_width (GTK_CONTAINER (window), 10);
//Die Größe des hauptfensters festlegen
gtk_widget_set_size_request (GTK_WIDGET (window), 800, 600);
//Signalverarbeitung des Hauptfensters machen. Wenn das Hauptfenster geschlossen wird, gibt es das Signal "destroy"!
g_signal_connect (window, "destroy", G_CALLBACK (exit_programm), NULL);
//Fixed Erstellen. Ein Container Widget (erste dicke Äste) das die anderen Widgets aufnimmt und worin diese angepasst werden können!
//Das Container-Widget "fixed" erstellen.
fixed = gtk_fixed_new();
//Das Containerwidget "fixed" in das Hauptfenster einfügen
gtk_container_add(GTK_CONTAINER(window), fixed);
//Jetzt einen Button 1 generieren.
//einen neuen Button erstellen
button1 = gtk_button_new_with_label("BUTTON1");
//Den neuen Button in das Container Widget "fixed" an entsprechender Stelle einfügen.
gtk_fixed_put(GTK_FIXED(fixed), button1, 10, 10);
//Die Größe des Buttons festlegen
gtk_widget_set_size_request(button1, 80, 30);
//Signalverarbeitung des Buttons machen. Wenn der Button geklickt wird, gibt es das Signal "clicked"!
g_signal_connect (button1, "clicked", G_CALLBACK (button1_clicked), NULL);
//Jetzt ein Entry erstellen zur Aufnahme der textbasierten Daten.
//Ein neues Entry erstellen
text_entry = gtk_entry_new();
//Das neue Entry in den Container "fixed" an entsprechender Stelle einfügen
gtk_fixed_put(GTK_FIXED(fixed), text_entry, 140, 10);
//Anzahl angeben, wie viele Zeichen in dem Entry angezeigt werden sollen
gtk_entry_set_width_chars(GTK_ENTRY(text_entry), 20);
//Festlegen, ob der Inhalt des Entrys auch herauskopiert oder anderweitig benutzt werden kann.
gtk_editable_set_editable(GTK_EDITABLE(text_entry), TRUE);
//Einen Textinhalt angeben, der beim Programmstart angezeigt wird, bis etwas in das Entry eingegeben wird.
gtk_entry_set_placeholder_text(GTK_ENTRY(text_entry), "TEXTDATEN");
//=======================TESTBEREICH FÜR WEITERE WIDGETS IN DER MAIN======================
//========================================================================================
//Abschluss der MAIN...
//Werden die einzelnen erstellten Widgets nicht direkt jedesmal explizit mit "gtk_widget_show(...)" auf dem Bildschirm dargestellt, so kann man dieses auch für alle Widgets gesamt machen...
gtk_widget_show_all (window);
//MAIN starten...
//Haupt-Ereignisschleife (MAIN) starten.
gtk_main ();
//Rückgabewert wenn die MAIN geschlossen wird. Für die 0 könnte auch eine Variable gesetzt werden.
//Diese würde dann den RETURN - Wert aufnehmen und in der "exit_programm" Funktion könnte dann
//diese Variable noch ausgewertet werden...
return 0;
}
//=================================================================
//Ab hier ist die Main beendet und es folgen die Funtionsaufrufe
//=================================================================
//=================================================================
//Funktion die angewendet wird, wenn das Programm geschlossen wird
//=================================================================
void exit_programm (GtkButton *button, gpointer data)
{
//Wird das Programm geschlossen, dann wird in das Terminal geschrieben...
g_print ("Exit Programm \n");
//Kommando zum absoluten und endgültigen Beendens eines GTK Programms
gtk_main_quit();
} //Ende des kompletten Programms...
//=================================================================
//Funktion wenn der Button 1 geklickt wurde.
//=================================================================
void button1_clicked (GtkButton *button, gpointer data)
{
//Wenn Button1 geklickt, dann wird in das Terminal geschrieben...
g_print ("Knopf '%s' geklickt!\n", gtk_button_get_label(button));
} //Ende Button 1
|
Wenn das Ganze unter main.c im Home-Verzeichnis gespeichert ist, dann das Terminal öffnen und den folgenden String hier herauskopieren und einfügen: | gcc $(pkg-config --cflags gtk+-3.0) -rdynamic -o test main.c $(pkg-config --libs gtk+-3.0)
|
Dieses startet den GCC Kompiler mit den benötigten Informationen und erzeugt das Programm mit Namen "test". Wenn die Kompilierung ohne Fehlermeldung abgeschlossen ist (Was bei diesem einfachen Programmcode auch so sein sollte), zeigt das Terminal wieder die Eingabeaufforderung an. Hier jetzt noch im Terminal folgendes eingeben, um das Programm zu starten. Dieses Beispiel kann man als Start in GTK verwenden, um die vorhandenen Widgets Stück für Stück auszuprobieren und zu erforschen wie GTK funktioniert. Hier habe ich als Container "fixed" ausgewählt. Es gibt jetzt bestimmt einige die diesen Container nicht mehr als geeignet sehen. Jedoch bietet dieser Container die Möglichkeit seine Widgets darin so zu positionieren und die Größe anzupassen wie man es von Entwicklungsumgebungen aus Windows her kennt. Das denke ich macht es dann doch erst einmal leichter die ersten Schritte mit GTK zu machen. Warum "fixed" nicht immer so beliebt ist und welche Nachteile dieser Container mit sich bringt, kann man dann immer noch später herausfinden und selber entscheiden, ob man daran festhält oder doch auf die modernere Art der Programmierung wechselt. Viel Spaß beim Start mit GTK wünscht allen Tom.
|
user_unknown
Anmeldungsdatum: 10. August 2005
Beiträge: 17552
Wohnort: Berlin
|
Ohne so ausführliche Kommentierung, ein Beispiel mit Java-Swing:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106 | // package
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
/**
Sample
@author Stefan Wagner
@date Do 21. Jan 15:13:24 CET 2021
*/
public class Sample extends JFrame implements ActionListener
{
private static final String progname = "Sample 0.1";
private JTextField jtfa;
private JTextField jtfb;
private JTextArea jta;
private JButton jb, jb2;
public Sample (String title)
{
super (progname);
JPanel mainpanel = new JPanel ();
mainpanel.setLayout (new BorderLayout ());
this.getContentPane ().add (mainpanel);
jtfa = new JTextField ("foo");
jtfb = new JTextField ("bar");
jb = new JButton ("foobar");
jb2 = new JButton ("Button 2");
jb.addActionListener (this);
jta = new JTextArea ();
JPanel buttonAndField = new JPanel ();
buttonAndField.setLayout (new BoxLayout (buttonAndField, BoxLayout.LINE_AXIS));
buttonAndField.add (jb);
buttonAndField.add (jtfa);
mainpanel.add (buttonAndField, BorderLayout.NORTH);
mainpanel.add (jtfb, BorderLayout.EAST);
mainpanel.add (jta, BorderLayout.CENTER);
mainpanel.add (jb2, BorderLayout.SOUTH);
setSize (400, 300);
setLocation (100, 100);
setTitle (title);
setDefaultCloseOperation (JFrame.EXIT_ON_CLOSE);
setVisible (true);
}
public void actionPerformed (final ActionEvent e)
{
SwingWorker worker = new SwingWorker ()
{
protected String doInBackground () throws InterruptedException
{
String cmd = e.getActionCommand ();
if (cmd.equals ("foobar"))
{
jta.setText ("Template Filled - foobar" + jtfa.getText ());
}
else
{
jta.setText ("Template Filled - else");
}
return "done";
}
protected void done ()
{
jtfa.setText ("done");
}
};
worker.execute ();
}
public static void main (final String args[])
{
Runnable runner = new Runnable ()
{
public void run ()
{
String param = null;
if (args.length != 1)
{
usage ();
System.exit (1);
}
param = args[0];
JFrame jf = new Sample (param);
jf.setLocationRelativeTo (null);
// new Sample (param);
}
};
EventQueue.invokeLater (runner);
}
public static void usage ()
{
System.out.println ("Usage:\tjava Sample param");
}
}
|
Kompilieren und Starten:
| javac Sample.java && java Sample asdf
|
Das JDK, also das Development-Kit muss installiert sein - ein JRE (Runtime Environment) reicht nicht.
|
Axel-Erfurt
Anmeldungsdatum: 18. Mai 2016
Beiträge: 1347
|
tom111 schrieb: Wenn das Ganze unter main.c im Home-Verzeichnis gespeichert ist, dann das Terminal öffnen und den folgenden String hier herauskopieren und einfügen: | gcc $(pkg-config --cflags gtk+-3.0) -rdynamic -o test main.c $(pkg-config --libs gtk+-3.0)
|
Dieses startet den GCC Kompiler mit den benötigten Informationen und erzeugt das Programm mit Namen "test". Wenn die Kompilierung ohne Fehlermeldung abgeschlossen ist (Was bei diesem einfachen Programmcode auch so sein sollte), zeigt das Terminal wieder die Eingabeaufforderung an. Hier jetzt noch im Terminal folgendes eingeben, um das Programm zu starten.
Gibts bei gcc auch eine Option ähnlich --no-pie bei g++ damit es auch ein Programm wird und keine Gemeinsame Bibliothek ? So bekomme ich ein z.B. Programm. | g++ -no-pie -o test main.c `pkg-config gtkmm-3.0 --libs --cflags`
|
|
ChickenLipsRfun2eat
Anmeldungsdatum: 6. Dezember 2009
Beiträge: 12067
|
tom111 schrieb: Da ich ja das "Startprogramm" von der Gnome/GTK Seite kritisiert hatte…
Danke für das Beispiel (habs aber noch nicht ausprobiert 😉 ). Aber bitte: Nenne dein Programm nicht test . test ist /usr/bin/test . Wenn nun einer nur test anstatt ./test angibt, passiert „nichts“. Lokal ist das kein Problem, ich hab auch in vermutlich jeder Sprache ein test, aber gerade für Anfänger ist das zusätzlich verwirrend. Axel-Erfurt schrieb: Gibts bei gcc auch eine Option ähnlich --no-pie bei g++ damit es auch ein Programm wird und keine Gemeinsame Bibliothek ?
Wieso sollte no-pie eine gemeinsame Bibliothek erstellen? No-pie hat was mit der Speicherverwaltung zu tun, bzw. verbietet diese „random“ zuzuweisen. Suchbegriff: position independent executable. An sich ganz einfach: Keine int main() , kein Programm. Um eine Bibliothek zu erstellen, kannst du bspw. gcc -c eins.c zwei.c /wo/anders/drei.c
ar -cqv libvier.a eins.o zwei.o drei.o nutzen, und dann deine Programme, die eins,zwei,drei verwenden mit -l /meine/libs/libvier.a (oder -l vier ) kompilieren. Darf natürlich dann keine main-Funktion drin sein.
|
Axel-Erfurt
Anmeldungsdatum: 18. Mai 2016
Beiträge: 1347
|
ChickenLipsRfun2eat schrieb: Wieso sollte no-pie eine gemeinsame Bibliothek erstellen?
Hatte ich nicht geschrieben, sondern | gcc $(pkg-config --cflags gtk+-3.0) -rdynamic -o test main.c $(pkg-config --libs gtk+-3.0)
|
erstellt eine gemeinsame Bibliothek | g++ -no-pie -o test main.c `pkg-config gtkmm-3.0 --libs --cflags`
|
erstellt ein Programm
|