Zukunft C: OOP

Das Internet hat eine interessante Neuigkeit umgangen : Es wurde bekannt, dass wahrscheinlich OOP-Tools, nämlich Klassen, zum nächsten Standard der Programmiersprache C hinzugefügt werden. Gleichzeitig ist es zu früh, um beurteilen zu können, ob dies umgesetzt wird, da dieses Dokument nicht endgültig angenommen und nicht zum Entwurf der nächsten Norm hinzugefügt wurde. Der Vorschlag, dies umzusetzen, kam 1995 von einem gewissen Robert Jervis, wurde aber erst jetzt bei der WG14 angenommen.

Lassen Sie uns versuchen, die Haut eines ungetöteten Bären zu teilen und zu sehen, was es bedroht und was es uns geben wird.

Betrachten Sie dazu einige Bereiche dieses Tools:

GUI


Viele Menschen wissen, dass es in diesem Fall ohne OOP fast unmöglich ist, etwas mit Bedacht zu tun. Daher verwendet GTK + die OOP-Simulation über GObject.

Hallo Welt!
#include 
int main (int argc, char *argv[])
{
    GtkWidget *window;
    GtkWidget *label;
    gtk_init(&argc, &argv);
    /* Create the main, top level window */
    window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    /* Give it the title */
    gtk_window_set_title(GTK_WINDOW(window), "Hello, world!");
    /* Center the window */
    gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
    /* Set the window's default size */
    gtk_window_set_default_size(GTK_WINDOW(window), 200, 100);
    /*
    ** Map the destroy signal of the window to gtk_main_quit;
    ** When the window is about to be destroyed, we get a notification and
    ** stop the main GTK+ loop by returning 0
    */
    g_signal_connect(window, "destroy", G_CALLBACK(gtk_main_quit), NULL);
    /*
    ** Assign the variable "label" to a new GTK label,
    ** with the text "Hello, world!"
    */
    label = gtk_label_new("Hello, world!");
    /* Plot the label onto the main window */
    gtk_container_add(GTK_CONTAINER(window), label);
    /* Make sure that everything, window and label, are visible */
    gtk_widget_show_all(window);
    /*
    ** Start the main loop, and do nothing (block) until
    ** the application is closed
    */
    gtk_main();
    return 0;
}


Wir sehen ein klassisches Bild für die Verwaltung von C-Daten auf dem Stapel durch Zeiger. Dies erfordert zusätzliche Aufmerksamkeit für die Deklaration derselben Zeiger. Dies wirkt sich auch erheblich auf die Wartung des Codes aus.

Stattdessen könnte man den in GTKMM (C ++) implementierten "nativen" Entwicklungsansatz verwenden.

Hallo Welt!
//HelloWorldWindow.h
#ifndef HELLOWORLDWINDOW_H
#define HELLOWORLDWINDOW_H
#include 
#include 
// Derive a new window widget from an existing one.
// This window will only contain a button labelled "Hello World"
class HelloWorldWindow : public Gtk::Window
{
  public:
    HelloWorldWindow();
  protected:
    void on_button_clicked(); //event handler
    Gtk::Button hello_world;
};
#endif
//HelloWorldWindow.cc
#include 
#include "HelloWorldWindow.h"
HelloWorldWindow::HelloWorldWindow()
 : hello_world("Hello World")
{
    // Set the title of the window.
    set_title("Hello World");
    // Add the member button to the window,
    add(hello_world);
    // Handle the 'click' event.
    hello_world.signal_clicked().connect(
        sigc::mem_fun(*this, &HelloWorldWindow::on_button_clicked));
    // Display all the child widgets of the window.
    show_all_children();
}
void HelloWorldWindow::on_button_clicked()
{
    std::cout << "Hello world" << std::endl;
}
//main.cc
#include 
#include "HelloWorldWindow.h"
int main(int argc, char *argv[]) 
{
    // Initialization
    Gtk::Main kit(argc, argv);
    // Create a hello world window object
    HelloWorldWindow example;
    // gtkmm main loop
    Gtk::Main::run(example);
    return 0;
}


Dies sieht zweifellos ausführlicher aus, aber die inhärenten Probleme von Zeigern verschwinden, z. B. Speicherlecks, Dereferenzierungsfehler und das Löschen von NULL-Zeigern. Wir erhalten auch sofort die Vorteile von OOP, z. B. Verkapselung, Polymorphismus und Vererbung. Dies findet eindeutig Anwendung in diesem Bereich, insbesondere in der Vererbung.

Low-Level-Programmierung


Eine der Hauptnischen, die diese berüchtigte Sprache einnimmt. Es gibt verschiedene Möglichkeiten, ein ähnliches Problem in C zu lösen. Am häufigsten ist jedoch der direkte Zugriff auf Maschinenregister.

PORTD = 0xff;

Dies birgt jedoch offensichtliche Nachteile: die einfache Erstellung eines Tippfehlers, die Erzeugung von wiederholtem Code, die Unlesbarkeit und die Komplexität der Wartung.

Es wäre bequemer, eine einfache Klasse zu implementieren.

class led {
public:
	led: port {*s}{/*..*/}
	ledOn(number) {/*...*/};
//...	
};

Erstellen Sie außerdem für jeden Port ein Objekt. Sie können dem Konstruktor auch zusätzliche Parameter hinzufügen, die die Porteinstellungen bestimmen, und eine Vielzahl verschiedener Methoden für komplexe Manipulationen, z. B. alle Portbits.

Problematisches Problem


In jedem Fall ist der Umfang dieses Tools offensichtlich. Sie erweitern die Funktionalität der Sprache und machen sie nicht nur effektiv, sondern auch bequemer. Aus objektiver Sicht ist dies durchaus notwendig, aber ... Ich denke, dass viele, auch beim Lesen des Titels, interne Dissonanzen hatten, weil es dafür C ++ gibt. Aber wird dies C selbst begrenzen? Wem sollte es wehtun? Die Sprache ist nicht mehr so ​​jung, ich habe es geschafft, viele stabile Klischees zu schaffen, aber die Zeit vergeht, die Zeit ist gekommen, sich zu ändern und die Notwendigkeit für selbstverständlich zu halten.

Jetzt auch beliebt: