Linux за българи: Форуми

На някой места C++ е мръсна дума - deamons, kernel, drivers, etc...

Честно казано, мисля че е по-добре първо да се учи Java, после C. Причината - C изглежда прекалено сложен за неопитния потребител. Java е несъмнено по-атрактивен и е полезен като помагало за разбиране на основните на програмирането. После задължително курс по C за да се научи наистина ефективно програмиране, и после се оставя на човека да си реши. Естествено Java може да бъде заменен със всеки друг език от високо ниво. Аз лично сега се уча на Vala, което си е 2в1 - пишеш на високо ниво, компилатора генерира нормален C код.

GeSHi (C++):
include <sceleton.h>
 
using namespace semetary;
 
while(corpse==die) {
                                    return tamqn;
                             }
:D
 
//////////////////////////////////////////////////маитапа настрана//////////////////////////////////////////////
 
// $Id: skeleton.h,v 1.1 2009/07/05 10:43:44 sms Exp $
 
//
// A skeleton class declaration.
 
// References:
//	1. Effective C++. Second Edition.
//		Scott Meyers.
//		ISBN:	0-201-92488
//
//	2. The C++ Programming Language
//		Bjarne Stroustrup.
//		ISBN:	0-201-53992-6
//
 
#include <iostream>		// No .h (Ref 1 Item 2)
 
class CCCCC: public BBBBB
{
public:
    // Constructors.
    //   Initialisation List
    //	   initialise all pointers (to zero) (Ref 1 Item 6, 12).
    //	   list members in order declared in class (Ref 1 Item 13).
 
    // Default Constructor
    //	The system will always provide one so make this private if you don't
    //  want it (Ref 1 Item 27). Remove the function if the default is ok.
    //	Used:
    //	  CCCCC c1;
    CCCCC () 
    {};
 
    // Copy constructor.
    //	The system will always provide one so make this private if you don't
    //  want it (Ref 1 Item 27). Remove the function if the default is ok.
    //	You will need to provide one if dynamic memory is used (Ref 1 Item 11).
    //	Used:
    //	  CCCCC c1(c2);
    //	  pass by value to function.
    //	  return value from function
 
    CCCCC (const CCCCC& rhs)
    {
	// Assign new dynamic memory and and copy over data (Ref 1 Item 11).
 
    }
 
    // Destructor
    //	The system will always provide one so make this private if you don't
    //  want it (Ref 1 Item 27). Remove the function if the default is ok.
    //	You will need to provide one if dynamic memory is used (Ref 1 Item 11).
    //	This should be virtual for Base classes.
 
    virtual ~CCCCC ()
    {
	// Delete all dynamic memory (Ref 1 Item 6).
    };
 
    // Operators.
    // Assignment operator.
    //	The system will always provide one so make this private if you don't
    //  want it (Ref 1 Item 27). Remove the function if the default is ok.
    //	You will need to provide one if dynamic memory is used (Ref 1 Item 11).
 
    CCCC& operator= (const CCCCC& rhs)
    {
	// Don't copy to self (Ref 1, Item 17).
	if (this != &rhs)
	{
	    // Make sure that the base class assigns too (Ref 1 Item 16).
	    BBBBB::operator= (rhs);
 
	    // Delete existing memory from this and assign new
	    // (Ref 1 Item 6, 11).
	    // Copy data from (non-NULL) pointers into new memory.
	    // Assign all data members (Ref 1 Item 16).
 
	}
	// Returns *this (Ref 1 Item 15).
	return *this;
    }
 
    // Address of operator (non const).
    //	The system will always provide one so make this private if you don't
    //  want it (Ref 1 Item 27). Remove the function if the default is ok.
    // Used:
    //	  CCCCC *c1 = &c2;
 
    CCCC* operator& ()
    {
	return (this);
    }
 
    // Address of operator (const).
    //	The system will always provide one so make this private if you don't
    //  want it (Ref 1 Item 27). Remove the function if the default is ok.
    // Used:
    //	  const CCCCC *c1 = &c2;
 
    const CCCC* operator& () const
    {
	return (this);
    }
 
 
    // The following operators can be declared (Ref 2 Section 7.2):
    // +   -   *   /   %   ^   &   |   ~   !
    // =   <   >   +=  -=  *=  /=  %=  ^=  &=
    // |=  <<  >>  >>= <<= ==  !=  <=  >=  &&
    // ||  ++  --  ->* ,   ->  []  ()  new delete
    // NB: CCCC operator++ () is pre-increment.
    //     CCCC operator++ (int) is post-increment.
    // There should be no public data members (Ref 1 Item 20).
 
private:
 
protected:
}
 
 
// I/O
//	Declare these in header file.
//	Define them in a source file
//
// Input
//	This is never a class member (Ref 1 Item 19).
//		Maybe a friend (Ref 1 Item 19).
//		Maybe use an access function.
 
istream& istream::operator>> (istream& in, CCCCC ccc)
{
    // (Ref 1 Item 19)
    // Ensure (perhaps by using accesors):
    // 		Delete any dynamically allocated data that will be overwritten
    // 		Allocate new dynamically allocated data
    // Read in data and set new values. eg:
    // 		in >> newData;
    // 		ccc.SetValue (newData);
    return (*in);
}
 
// Output
//	This is never a class member (Ref 1 Item 19).
//		Maybe a friend (Ref 1 Item 19).
//		Maybe use an access function.
 
ostream& ostream::operator<< (ostream& out, CCCCC ccc)
{
    // Extract the data from the object. eg:
    // 		out << ccc.printable();
    return (*out);
}
 
 

GeSHi (C++):
#include <sys/types.h>
#include <sys/stat.h>
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <errno.h>
#include <unistd.h>
#include <syslog.h>
#include <string.h>
 
int main(void) {
 
        /* Our process ID and Session ID */
        pid_t pid, sid;
 
        /* Fork off the parent process */
        pid = fork();
        if (pid < 0) {
                exit(EXIT_FAILURE);
        }
        /* If we got a good PID, then
           we can exit the parent process. */
        if (pid > 0) {
                exit(EXIT_SUCCESS);
        }
 
        /* Change the file mode mask */
        umask(0);
 
        /* Open any logs here */        
 
        /* Create a new SID for the child process */
        sid = setsid();
        if (sid < 0) {
                /* Log the failure */
                exit(EXIT_FAILURE);
        }
 
 
 
        /* Change the current working directory */
        if ((chdir("/")) < 0) {
                /* Log the failure */
                exit(EXIT_FAILURE);
        }
 
        /* Close out the standard file descriptors */
        close(STDIN_FILENO);
        close(STDOUT_FILENO);
        close(STDERR_FILENO);
 
        /* Daemon-specific initialization goes here */
 
        /* The Big Loop */
        while (1) {
           /* Do some task here ... */
 
           sleep(30); /* wait 30 seconds */
        }
   exit(EXIT_SUCCESS);
}