Παραδείγματα Aσκήσεων στην C
Στη δημοσίευση αυτή, μπορεί ο κάθε ένας να προσθέσει το πρόγραμμά του είτε είναι απλό είτε σύνθετο. Τα προγράμματα θα πρέπει να είναι γραμμένα στην C και καλό είναι να τρέχουν με είσοδο το Ν και όχι κάποιον συγκεκριμένο αριθμό! Με άλλα λόγια να γράφετε το πρόγραμμά σας όσο γίνεται πιο γενικό. Έχω δημιουργήσει έναν πίνακα περιεχομένων όπου θα μπορείτε πιο εύκολα πιστεύω να μεταφερθείτε στο πρόγραμμα που θέλετε.
Πίνακας περιεχομένων
Απλά παραδείγματα
Εντολές συνθήκης if else
Αναδρομή
- Εύρεση του παραγοντικού Ν
- Υπολογισμός παραγοντικού/δύναμης με χρήση της switch
- Διάβασμα τυχαίου πλήθους ακεραίων μέχρι να διαβαστεί ο '0' και τύπωμα τους σε αντίστροφη σειρά
Εντολές επανάληψης(loops)
- Υπολογίζει και τέλος εκτυπώνει το άθροισμα των ακεραίων απο 1 έως Ν
- Υπολογίζει το άθροισμα των περιττών αριθμών απο 1 έως ΜΑΧ
- Υπολογίζει το άθροισμα των άρτιων αριθμών απο 1 έως ΜΑΧ
- Υπολογισμός αθροίσματος και μέσου όρου ή μεγίστου 3 αριθμών
- Υπολογίζει το άθροίσμα των πρώτων αριθμών απο 1 εως ΜΑΧ
- Διαβάζει αριθμούς μέχρι να διαβαστεί ο αριθμός 999 οπότε σταματά η διαδικασία ανάγνωσης(λεπτομέριες μέσα στο πρόγραμμα)
Δείκτες(pointers)
- Εξάσκηση σε pointers(παράδειγμα_1)
- Εξάσκηση σε pointers(παράδειγμα_2)
- Εξάσκηση σε pointers(παράδειγμα_3)
- Εναλλαγή δυο δεικτών ανεξαρτήτου τύπου
- Άθροισμα 2 αιθμών(χρήση δεικτών-tricky)
- Εκτύπωση των στοιχείων ενός πίνακα κανονικά και αντίστροφα
- Πολ/σμός και πρόσθεση με χρήση δεικτών
Πίνακες(arrays)
Συμβολοσειρές(strings)
- Υπολογισμός αν μια συμβολοσειρά είναι καρκινική επιστρέφοντας Α/Ψ και το μήκος της συμβολοσειράς
- Πρόγραμμα που διαβάζει ένα string, το αντιστρέφει και το τυπώνει
- Yλοποίηση βασικών συναρτήσεων της βιβλιοθήκης <string.h>
- Αντιστροφή λέξεων μιας πρότασης
- Απλός χειρισμός strings | συγκρισεις / υπολογισμός μήκους
Αρχεία(files)
- Άνοιγμα και προσθήκη συμβολοσειράς στο τέλος ενός αρχείου
- Εξάσκηση σε files(παράδειγμα_1)
- Παράδειγμα καταχώρησης 3 εγγραφών σε αρχείο, και κατόπιν αλλαγή της 3ης και της 1ης
Γραφικά
Επιπλέον
- Διάβασμα ενός string από τον χρήστη και μετατροπή του σε πραγματικό αριθμό
- Υπολογισμός του χώρου που πιάνει στη μνήμη μια μεταβλητή τύπου struct
- Υπολογισμός αριθμών που διαιρούν τέλεια
Παραδείγματα & Ασκήσεις
Εκτυπώνει ένα απλό μήνυμα στην οθόνη
απο: linuxs
- Κώδικας: Επιλογή όλων
#include <stdio.h>
int main(){
printf("Hello world\n");
return 0;
}
Contents
Διάβασμα ενός ακεραίου απο το πληκτρολόγιο
απο: linuxs
- Κώδικας: Επιλογή όλων
#include <stdio.h>
int main(){
int a;
printf("Please type an integer to read:");
scanf("%d", &a);
printf("You have just typed: %d\n", a);
return 0;
}
Contents
Εύρεση αν η είσοδος(integer) ξεπερνά η όχι το 10
απο: linuxs
- Κώδικας: Επιλογή όλων
#include <stdio.h>
int main(){
int a;
printf("Please type an integer to read:");
scanf("%d", &a);
if(a>10) {
printf("Student passed!\n");
}else{
printf("Student must repeat the class!\n");
}
return 0;
}
Contents
Υπολογίζει και τέλος εκτυπώνει το άθροισμα των ακεραίων απο 1 έως Ν
απο: linuxs
- Κώδικας: Επιλογή όλων
/**************************************************************
Υπολογίζει και εκτυπώνει το άθροισμα απο 1 έως N
*************************************************************/
#include <stdio.h>
#define N 1000
int main(void) {
int i, sum=0;
for(i=1; i<=N; i++){
sum+=i;
}
printf("The sum from 1 to %d = %d\n", N, sum);
return 0;
}
Contents
Υπολογίζει το άθροισμα των περιττών αριθμών απο 1 έως ΜΑΧ
απο: migf1
- Κώδικας: Επιλογή όλων
/* -------------------------------------------------------------
* Υπολογίζει και τυπώνει το άθροισμα των περιττών αριθμών από
* το 1 έως MAX (συμπεριλαμβανομένων)
* Για την εύρεση του αν ένας αριθμός είναι περιττός, εξετάζει αν
* το υπόλοιπο της διαίρεσής του με το 2 είναι διάφορο του μηδενός
* (όταν το υπόλοιπο της διαίρεσης είναι 0, τότε ο αριθμός είναι άρτιος)
* -------------------------------------------------------------
*/
#include <stdio.h>
#define MAX 1000 // αλλάξτε το σε όποιον θετικό ακέραιο θέλετε
int main ( void )
{
long oddsum = 0;
register int i;
for (i=1; i < MAX+1; i++)
if ( i%2 != 0 )
oddsum += i;
printf("Sum of odd numbers from 1 to %d = %ld\n", MAX, oddsum);
return 0;
}
Contents
Υπολογίζει το άθροισμα των άρτιων αριθμών απο 1 έως ΜΑΧ
απο: migf1
- Κώδικας: Επιλογή όλων
/*****************************************************************************************************
Υπολογίζει και τυπώνει το άθροισμα των άρτιων αριθμών από
το 1 έως MAX (συμπεριλαμβανομένων)
Για την εύρεση του αν ένας αριθμός είναι άρτιος, εξετάζει αν
το υπόλοιπο της διαίρεσής του με το 2 είναι ίσο με το μηδεν
(όταν το υπόλοιπο της διαίρεσης διαφορετικό απο το 0, τότε ο αριθμός είναι περιττός)
*****************************************************************************************************/
#include <stdio.h>
#define MAX 1000
int main ( void )
{
long evensum = 0;
register int i;
for (i=1; i < MAX+1; i++)
if ( i%2 == 0 )
evensum += i;
printf("Sum of even numbers from 1 to %d = %ld\n", MAX, evensum);
return 0;
}
Contents
Υπολογισμός αθροίσματος και μέσου όρου ή μεγίστου 3 αριθμών
απο: clepto
- Κώδικας: Επιλογή όλων
/******************************************************************************************
Το πρόγραμμα θα παίρνει ως είσοδο 3 ακέραιους αριθμούς και θα υπολογίζει
το άθροισμα τους, αν το άθροισμα είναι μεγαλύτερο του μηδέν να βρίσκει
τον μέσο όρο ενώ σε διαφορετική περίπτωση να δίνει τον μεγαλύτερο.
******************************************************************************************/
#include <stdio.h>
main(void) {
int x, y, a, xya, moxya;
printf("ΔΩΣΕ 3 ΑΡΙΘΜΟΥΣ");
scanf("%d %d %d", &x, &y, &a);
xya = x+y+a;
printf("ΤΟ ΑΘΡΟΙΣΜΑ ΤΟΥΣ ΕΙΝΑΙ %d /n", xya);
if (xya>0) {
moxya = xya/3;
printf("Ο ΜΕΣΟΣ ΟΡΟΣ ΕΙΝΑΙ %d", moxya);
}
else if (xya<=0) {
if (x>y && x>a) {
printf("μεγαλύτερο είναι το %d", x);
}
else if (y>x && y>a) {
printf("μεγαλύτερο είναι το %d", y);
}
else if (a>x && a>y) {
printf("μεγαλύτερο είναι το %d", a);
}
}
}
Contents
Διάβασμα τυχαίου πλήθους ακεραίων μέχρι να διαβαστεί ο '0' και τύπωμα τους σε αντίστροφη σειρά
απο: migf1
- Κώδικας: Επιλογή όλων
/* -------------------------------------------------------------
* Διαβάζει ακέραιους από τον χρήστη μέχρι να διαβάσει τον 0,
* οπότε σταματάει το διάβασμα και τυπώνει τους διαβασμένους
* ακέραιους σε αντίστροφη σειρά.
* Το πρόγραμμα χρησιμοποιεί recursion
* -------------------------------------------------------------
*/
#include <stdio.h>
// ------------------------------------------------
void print_reverse( int n )
{
if ( n == 0 )
return;
printf("enter an int (0 to stop): ");
scanf("%d", &n);
print_reverse( n );
printf("%d ", n);
return;
}
// ------------------------------------------------
int main ( void )
{
int n;
print_reverse(n);
return 0;
}
Contents
Εύρεση του παραγοντικού Ν
απο: migf1
- Κώδικας: Επιλογή όλων
/* -------------------------------------------------------------
* Διαβάζει έναν φυσικό αριθμό από το 1 έως το 33 και χρησιμοποιεί
* recursion για να υπολογίζει το το παραγοντικό του
* -------------------------------------------------------------
*/
#include <stdio.h>
// ------------------------------------------------
unsigned long int factorial( int n )
{
if ( n == 1 )
return 1;
return n * factorial( n-1 );
}
// ------------------------------------------------
int main ( void )
{
int n;
do {
printf("enter a natural num (1-33): ");
scanf("%d", &n);
} while (n < 1 || n > 33);
printf("factorial of %d: %lu\n", n, factorial(n) );
return 0;
}
Contents
Υπολογίζει το άθροίσμα των πρώτων αριθμών απο 1 εως ΜΑΧ
απο: migf1
- Κώδικας: Επιλογή όλων
/* -------------------------------------------------------------
* Τυππωνει και αθροίζει του πρώτους αριθμούς από το 1 έως το MAX
* -------------------------------------------------------------
*/
#include <stdio.h>
#include <math.h>
#define MAX 15
int main ( void )
{
long primesum = 0;
register int i, j;
int isprime = 1;
for (i=2; i <= MAX; i++)
{
for (j=2; j<=sqrt(i); j++)
{
if ( i%j == 0 ) {
isprime = 0; // FALSE
break;
}
}
if ( isprime ) {
printf("%d is a prime\n", i);
primesum += i;
}
isprime = 1; // TRUE
}
printf("\nSum of prime numbers from 1 to %d = %ld\n", MAX, primesum);
return 0;
}
Contents
Άνοιγμα και προσθήκη συμβολοσειράς στο τέλος ενός αρχείου.
απο: Star_Light
- Κώδικας: Επιλογή όλων
#include <stdio.h>
int main()
{
FILE *ptr; /*the file pointer*/
char *str="links.txt";
ptr=fopen(str,"a"); /*EPISTROFI deikti tipou FILE apo tin fopen
enw an sumvei la8os sti diarkeia tis diadikasias anoigmatos enos arxeiou 8a epistrepsei
enan deikti NULL diladi enan deikti pou deixnei se mi egkura dedomena */
fprintf(ptr,"The end of file");
fclose(ptr);
return 0;
}
Contents
Υπολογισμός παραγοντικού/δύναμης με χρήση της switch
απο: Star_Light
- Κώδικας: Επιλογή όλων
/*==========================
Upologismos paragontikou h dunamis enos arithmou
analoga me tin epilogi tou xrhsth mesw tis switch
=============================
*/
#include<stdio.h>
int main()
{
int r;
int n;
int a;
char flag;
printf("Dwste enan akeraio arithmo: ");
scanf("%d",&a);
printf("Dwste ton akeraio ektheti: ");
scanf("%d",&n);
printf("Dwste A gia ton upologismo tou paragontikou H B gia tin dunami : \n");
scanf("%c",&flag);
flag=getchar();
switch(flag)
{
case 'A':
r=paragontiko(n);
printf("To apotelesma einai: %d \n",r);
break;
case 'B':
r= dunami(a,n);
printf("To apotelesma einai: %d\n",r);
break;
default:
printf("Den dwsate ta swsta stoixeia. Ksanadokimaste: \n");
break;
}
return 0;
}
int paragontiko(int n)
{
if (n==0)
return 1;
else
return n * paragontiko((n-1));
}
int dunami(int a , int n)
{
if(n==0)
return 1;
else
return a * dunami(a , n-1);
}
Contents
Διαβάζει ένα string από τον χρήστη και του απαντάει αν είναι παλινδρομικός
απο: migf1
- Κώδικας: Επιλογή όλων
/* ---------------------------------------------------------------------
* Διαβάζει ένα string από τον χρήστη και του απαντάει αν είναι παλινδρομικό.
* Παλινδρομικά (ή καρκινικά) ονομάζονται όσα strings διαβάζονται κι από τις μεριές
* ---------------------------------------------------------------------
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// ------------------------------------------------------------------------------------
int s_ispalindrome(char *s)
{
if ( !s ) // early exit
return 0;
char *cp1, *cp2;
cp2 = s + strlen(s) - 1; // set cp2 at end of s
for (cp1=s; cp1 < cp2 && *cp1 == *cp2; cp1++, cp2--)
;
return (cp1 >= cp2);
}
//-------------------------------------------------------------------------------------
int main( void )
{
char s[256] = "";
printf("Enter your string: ");
fgets(s, 256, stdin);
s[ strlen(s)-1 ] = '\0';
printf( "\t\"%s\" is%s palindromic\n",
s,
s_ispalindrome(s) ? "" : " not"
);
exit( EXIT_SUCCESS );
}
Contents
Εξάσκηση σε pointers-παράδειγμα_1
απο: linuxs
- Κώδικας: Επιλογή όλων
#include <stdio.h>
#include <stdlib.h>
int main(void){
int rate;
int *ptr_rate;
rate=100;
ptr_rate = &rate;
printf("%d \n", rate);
printf("%p \n", &rate);
printf("%p \n", ptr_rate);
printf("%d \n", *ptr_rate);
return 0;
}
Contents
Εξάσκηση σε pointers-παράδειγμα_2
απο: linuxs
- Κώδικας: Επιλογή όλων
# include <stdio.h>
int main(){
int var1;
float var2;
char var3;
int *p_var1;
float *p_var2;
char *p_var3;
var1 = 32;
var2 = 32.142564;
var3 = 'f';
p_var1 = &var1;
p_var2 = &var2;
p_var3 = &var3;
printf("\n %d \n %f \n %c \n", var1, var2, var3);
printf("\n %p \n %p \n %p \n", p_var1, p_var2, p_var3);
return 0;
}
}
Contents
Εξάσκηση σε pointers-παράδειγμα_3
απο: linuxs
- Κώδικας: Επιλογή όλων
#include <stdio.h>
int var = 1;
int *ptr;
int main(void){
ptr=&var;
printf(" \n Direct access, var = %d", var);
printf(" \n Indirect access, var = %d", *ptr);
printf(" \n\n The address of var = %p", &var);
printf(" \n The address of var = %p \n", ptr);
return 0;
}
Contents
Εξάσκηση σε αρχεία-παράδειγμα_1
απο: linuxs
- Κώδικας: Επιλογή όλων
/* Opens and reads a file using fgets */
#include <stdio.h>
#include <stdlib.h>
int main(void){
FILE *infile;
char buf[81];
infile = fopen("lala.txt","r");
if(infile == NULL){
printf("File does not exist.\n");
exit(1);
}
while(fgets(buf, 81, infile) != NULL){
fputs(buf, stdout);
}
fclose(infile);
return 0;
}
Contents
Εναλλαγή δυο δεικτών ανεξαρτήτου τύπου
απο: migf1
- Κώδικας: Επιλογή όλων
/* --------------------------------------------------------------------------
* Παράδειγμα εναλλαγής δυο δεικτών (pointer swapping) ανεξαρτήτως τύπου.
* Τα ορίσματα της συνάρτησης swap_pointers() ορίζονται με τον γενικο τύπο: void,
* ώστε κατά την κλήση της συνάρτησης και με το αντίστοιχο type casting
* να λειτουργεί σωστά με οποιονδήποτε τύπο δεικτών.
*
* Το πρόγραμμα παρουσιάζει κώδικα για την εναλλαγή δεικτών σε 2 απλούς int,
* σε 2 συμβολοσειρές, σε 2 πίνακες από int και σε 2 struct.
* --------------------------------------------------------------------------
*/
#include <stdio.h>
#include <stdlib.h>
#define MAX_ARRELEMS 5 // απλά μια βοηθητική σταθερά
// -----------------------------------------------------------------------------------
// Η βασική μας συνάρτηση που εναλλάσσει δυο δείκτες, ανεξαρτήτως τύπου
//
void swap_pointers( void **x, void **y)
{
void *temp = *x;
*x = *y;
*y = temp;
return;
}
// -----------------------------------------------------------------------------------
// βοηθητική συνάρτηση που τυπώνει τα στοιχεία ενός πίνακα από int arr, μεγέθους len
//
void print_array( int arr[], int len )
{
register int i;
for (i=0; i < len; i++)
printf("%d ", arr[i]);
return;
}
// -----------------------------------------------------------------------------------
int main( void )
{
// swapping int pointers
int x=10, y=20;
int *px = &x, *py = &y;
puts("\nSWAPPING INTEGER POINTERS\n-------------------------");
printf("before:\t\tpx = %d,\tpy = %d\n", *px, *py);
swap_pointers( (void **) &px, (void **) &py );
printf("after :\t\tpx = %d,\tpy = %d\n\n", *px, *py);
// swapping char pointers
char *cpx = "string 1";
char *cpy = "string 2";
puts("\nSWAPPING CHARACTER POINTERS\n---------------------------");
printf("before:\t\tcpx = \"%s\",\tcpy = \"%s\"\n", cpx, cpy);
swap_pointers( (void **) &cpx, (void **) &cpy );
printf("after :\t\tcpx = \"%s\", \tcpy = \"%s\"\n\n", cpx, cpy);
// swapping array pointers
int xarr[MAX_ARRELEMS] = { 0, 1, 2, 3, 4 };
int yarr[MAX_ARRELEMS] = { 5, 6, 7, 8, 9 };
int *pxarr = xarr, *pyarr = yarr;
puts("\nSWAPPING ARRAY POINTERS\n-----------------------");
printf("before:\t\tpxarr = { ");
print_array( pxarr, MAX_ARRELEMS);
printf("}\tpyarr = { ");
print_array( pyarr, MAX_ARRELEMS);
puts("}");
swap_pointers( (void **) &pxarr, (void **) &pyarr );
printf("after :\t\tpxarr = { ");
print_array( pxarr, MAX_ARRELEMS);
printf("}\tpyarr = { ");
print_array( pyarr, MAX_ARRELEMS);
puts("}\n");
// swapping struct pointers
struct test { float w; float z; char s[256]; };
struct test xst = { .w = 10.0, .z = 20.0, .s = "x-string"};
struct test yst = { .w = 30.0, .z = 40.0, .s = "y-string" };
struct test *pxst = &xst, *pyst = &yst;
puts("\nSWAPPING STRUCT POINTERS\n------------------------");
printf( "before:\t\tpxst = {%.1f %.1f \"%s\"}\tpyst = {%.1f %.1f \"%s\"}\n",
pxst->w, pxst->z, pxst->s, pyst->w, pyst->z, pyst->s
);
swap_pointers( (void **) &pxst, (void **) &pyst );
printf( "before:\t\tpxst = {%.1f %.1f \"%s\"}\tpyst = {%.1f %.1f \"%s\"}\n",
pxst->w, pxst->z, pxst->s, pyst->w, pyst->z, pyst->s
);
fflush(stdin); getchar();
exit( EXIT_SUCCESS);
}
Contents
Διάβασμα ενός string από τον χρήστη και μετατροπή του σε πραγματικό αριθμό
απο: migf1
- Κώδικας: Επιλογή όλων
/* -----------------------------------------------------------------------------------
* Από: migf1
*
* Διάβασμα ενός string από τον χρήστη και μετατροπή του σε πραγματικό αριθμό.
*
* Το πρόγραμμα παρουσιάζει τον πλέον συμβατό και ασφαλή τρόπο να διαβάζει
* κανείς μεταβλητές οποιουδήποτε τύπου στη C, χωρίς να εξαρτάται από εν δυνάμει
* προβληματικές συναρτήσεις, όπως είναι η στάνταρ scanf().
*
* Στην προκειμένη περίπτωση το string μετατρέπεται σε double, αλλά μπορεί εξίσου
* εύκολα να μετατρταπεί σε οποινδήποτε άλλον τύπο, με χρήση της στάνταρ βιβλιοθήκης
* stdlib ( #include <stdlib.h> ).
*
* Η προτεινόμενη συνάρτηση είναι η strtod() η οποία δίνει πολλές δυνατότητας ελέγχου
* αποτυχίας της μετατροπής, με χρήση της καθολικής μεταβλητής errno (#include <errno.h)
* αλλά και του δείκτη: char *dummy στο 2ο όρισμά της. Εδώ παρουσιάζω μονάχα μερικές
* από αυτές τις δυνατότητες (για περισσότερες πληροφορίες, διαβάστε την τεκμηρίωση
* της συνάρτησης, στο manual της ).
*
* Ως ευκολότερη λύση για την μετατροπή, αλλά χωρίς δυνατότητα ελέγχου ενδεχόμενης
* αποτυχίας, παρουσιάζω και την συνάρτηση: atof() ( επίσης στη βιβλιοθήκη: stdlib) ).
*
* -----------------------------------------------------------------------------------
*/
#include <stdio.h>
#include <errno.h> // για έλεγχο του errno
#include <stdlib.h> // για τις atof(), strtod() και exit()
#define MAX_LINE 255+1 // μέγιστο μήκος της γραμμής εισόδου
// -----------------------------------------------------------------------------------
// Ανάγνωση του string s από την κύρια είσοδο μέχρι να πατηθεί ENTER ή να συμπληρωθούν
// malen-1 χαρακτήρες.
// Επιστρέφει το αναγνωσμένο s με μηδενισμένο τον τελικό του χαρακτήρα (αντικαθιστώντας
// το ENTER, αν ήταν αυτό ο τελικός χαρακτήρας). Σε περίπτωση σφάλματος επιστρέφει NULL.
// ΣΗΜΑΝΤΙΚΟ:
// το s πρέπει να είναι ήδη δημιουργημένο και να έχει χώρο για τουλάχιστον maxlen
// χαρακτήρες!
//
char *s_get(char s[], int maxlen)
{
register int i;
for (i=0; (s[i]=getchar()) != '\n' && i < maxlen-1; i++)
; // for-loop με κενό σώμα
s[i] = '\0'; // μηδενισμός του τελικού χαρακτήρα
return s;
}
// -----------------------------------------------------------------------------------
int main( void )
{
extern int errno; // defined in <errno.h>
char line[MAX_LINE]; // η γραμμή ειδόδου (string)
char *dummy; // για την strtod()
double num = 0.0; // το αποτέλεσμα της μεταροπής
printf("Enter any real number: ");
s_get( line, MAX_LINE);
printf("You entered the string: %s\n", line);
// μετατροπή με την atof()
num = atof( line );
printf("\nConverted to double with atof() it gives: %g\n", num);
// μετατροπή με την strtod()
errno = 0;
num = strtod( line, &dummy );
// έλεγχος αποτυχίας
printf("\nConverted to double with strtod() it gives: %g\n", num);
if (errno == ERANGE)
puts("\t*** error: number too big or too small");
if ( *dummy != '\0')
printf("\t*** info: \"%s\" was invalid so it was ignored\n", dummy);
exit( EXIT_SUCCESS );
}
Contents
Απλοϊκό πρόγραμμα δημιουργίας και απεικόνισης γραφήματος μιας συνάρτησης: f(x) = a*x + b
απο: migf1
- Κώδικας: Επιλογή όλων
/* -----------------------------------------------------------------------
* Από: migf1
*
* Πολύ απλοϊκό παράδειγμα προγράμματος κονσόλας που παράγει το γράφημα μιας
* συνάρτησης: f(x) = a*x + b στο πρώτο τεταρτημόριο του καρτεσιανού επιπέδου.
*
* Μπορείτε να αλλάξετε την συνάρτηση, αλλά σημειώστε πως το πρόγραμμα απεικονίζει
* μονάχα όσα σημεία παράγονται στην περιοχή: (0,0) ... (74,22)
* -----------------------------------------------------------------------
*/
#include <stdio.h>
#include <stdlib.h>
#define MAXCOLS 75 // μέγιστο πλάτος της οθόνης μας
#define MAXROWS 23 // μέγιστο ύψος της οθόνης μας
#define PIXEL_ON '#' // χαρακτήρας απεικόνισης "αναμμένων" pixels
#define PIXEL_OFF '.' // χαρακτήρας απεικόνισης "σβησμένων" pixels
#define VALIDPIXEL(x,y, w,h) ( (y) > -1 && (y) < (h) && (x) > -1 && (x) < (w) )
#define REVAXIS(y,h) (h) - (y) - 1 // αλλάζει την συντεταγμένη y ώστε το σημείο
// στο οποίο αντιστοιχεί να απεικονιστεί στην
// αντεστραμμένη φορά του άξονά (χρήσιμο για τον
// άξονα Υ που τον θέλουμε να μετράει από κάτω
// προς τα πάνω)
typedef struct screen {
int nrows; // τρέχον πλάτος της οθόνης μας
int ncols; // τρέχον ύψος της οθόνης μας
char pixel[MAXROWS][MAXCOLS]; // όλα τα pixels της οθόνης μας
} Screen;
// ------------------------------------------------------------------------------------
// Η συνάρτηση που παράγει το γράφημα (δοκιμάστε και με άλλες τιμές)
//
int f( int x )
{
return x/3+1;
}
// ------------------------------------------------------------------------------------
// "Ανάβει" το pixel (x,y) ώστε να εμφανιστεί αναμένο όταν αργότερα τυπωθεί η οθόνη
// μέσω της συνάρτησης: draw_screen()
//
void set_pixel( Screen *screen, int x, int y )
{
if ( !VALIDPIXEL(x,y, screen->ncols, screen->nrows ) )
return;
y = REVAXIS(y, screen->nrows); // make y-axis to start from bottom to top
screen->pixel[y][x] = PIXEL_ON;
return;
}
// ------------------------------------------------------------------------------------
// "Σβήνει" όλα τα pixels της οθόνης, ώστε να εμφανιστούν σβησμένα όταν αργότερα
// τυπωθεί η οθόνη μέσω της συνάρτησης: draw_screen()
//
void clear_screen( Screen *screen )
{
register int x,y;
for (y=0; y < screen->nrows; y++)
for (x=0; x < screen->ncols; x++)
screen->pixel[y][x] = PIXEL_OFF;
return;
}
// ------------------------------------------------------------------------------------
// Τυπώνει όλα τα pixels της οθόνης μας (αναμμένα και σβηστά) καθώς και την αρίθμηση
// των αξόνων Χ και Υ
//
void draw_screen( Screen screen )
{
register int x, y;
for (y=0; y < screen.nrows; y++)
{
// display value-labels to the left of y-axis
int ylab = y;
printf("%3d ", REVAXIS(ylab, screen.nrows) );
// display yth row of pixels
for (x=0; x < screen.ncols; x++)
putchar( screen.pixel[y][x] );
putchar('\n');
}
// display value-labels under x-axis
printf("Y/X ");
for (x=0; x < screen.ncols; x++)
printf("%d", x%10);
putchar('\n');
return;
}
// ------------------------------------------------------------------------------------
int main( void )
{
register int x=0;
Screen screen = { .ncols = MAXCOLS, .nrows = MAXROWS };
clear_screen( &screen ); // σβήσιμο όλων των pixels
for (x=0; x < screen.ncols; x++) // άναμμα μόνο όσων pixels...
set_pixel( &screen, x, f(x) ); // ... υπολογιζει η συνάρτηση f(x)
draw_screen( screen ); // τύπωμα όλων των pixels
exit( EXIT_SUCCESS );
}
Output: http://img6.imageshack.us/img6/7920/image2ks.jpg
Contents
Παράδειγμα καταχώρησης 3 εγγραφών σε αρχείο, και κατόπιν αλλαγή της 3ης και της 1ης
απο: migf1
- Κώδικας: Επιλογή όλων
/* -------------------------------------------------------------
* Από: migf1
* Παράδειγμα καταχώρησης 3 εγγραφών σε αρχείο, και κατόπιν αλλαγή της 3ης και της 1ης
* -------------------------------------------------------------
*/
#include <stdio.h>
#include <stdlib.h>
#define MAXLEN_ID (3+1) // μέγιστο μήκος κωδικού
#define MAXLEN_NAME (25+1) // μέγιστο μήκος ονόματος
#define myexit(n) printf("\npress ENTER to exit..."); fflush(stdin); getchar(); exit((n))
typedef enum { FALSE=0, TRUE } bool;
typedef struct rec { // δομή εγγραφής
char id[ MAXLEN_ID ]; // κωδικός
char name[ MAXLEN_NAME ]; // όνομα
} Rec;
// ------------------------------------------------------------------------------------
// Αντιγραφή του string: src στο string: dst (έως n-1 χαρακτήρες)
//
char *s_ncopy( char *dst, const char *src, int n )
{
char *save = dst;
while ( (dst-save) < n-1 && (*dst=*src) != '\0' )
dst++, src++;
if ( *dst )
*dst = 0;
return save;
}
// ------------------------------------------------------------------------------------
// Δημιουργία της εγγραφής: rec στην μνήμη, με κωδικό: id και όνομα: name
//
Rec *rec_set( Rec *rec, const char *id, const char *name )
{
if ( !rec )
return NULL;
s_ncopy( rec->id, id, MAXLEN_ID );
s_ncopy( rec->name, name, MAXLEN_NAME );
return rec;
}
// ------------------------------------------------------------------------------------
// Ανάγνωση της εγγραφής: rec που βρίσκεται στη θέση: fpos του αρχείου: fp
//
bool rec_fread( FILE *fp, const int fpos, Rec *rec )
{
if ( !fp )
return FALSE;
if ( fseek( fp, (fpos-1) * sizeof(Rec), SEEK_SET ) != 0 )
return FALSE;
if ( fread( rec, sizeof(Rec), 1, fp ) != 1 )
return FALSE;
return TRUE;
}
// ------------------------------------------------------------------------------------
// Καταχώρηση της εγγραφής: newrec στη θέση: fpos του αρχειου: fp
//
bool rec_fwrite( FILE *fp, const int fpos, const Rec *newrec )
{
if ( !fp )
return FALSE;
if ( fseek( fp, (fpos-1) * sizeof(Rec), SEEK_SET ) != 0 )
return FALSE;
if ( fwrite( newrec, sizeof(Rec), 1, fp ) != 1 )
return FALSE;
return TRUE;
}
// ------------------------------------------------------------------------------------
// Ανάγνωση και τύπωμα όλων των εγγραφών του αρχείου: fp
//
bool f_print( FILE *fp )
{
if ( !fp )
return FALSE;
if ( fseek( fp, 0, SEEK_SET ) != 0 ) // μεταπήδηση στην αρχή του αρχείου
return FALSE;
Rec rec; // προσωρινή εγγραφή
puts("File Contents\n-------------");
while ( fread( &rec, sizeof(Rec), 1, fp ) )
printf( "%s %s\n", rec.id, rec.name );
putchar('\n');
return TRUE;
}
// ------------------------------------------------------------------------------------
int main( void )
{
char fname[] = "b.txt"; // το όνομα του αρχείου
Rec rec = { .id="", .name="" }; // προσωρινή δομή εγγραφής
FILE *fp = fopen( fname, "w+" ); // άνοιγμα του αρχείου
if ( !fp ) { // αποτυχία
puts("*** fatal error: fopen() failed"); // προώρος τερματισμός
myexit(1);
}
/* αποθήκευση 3 εγγραφών (χωρίς έλεγχο για σφάλματα) */
rec_set( &rec, "001", "Giorgos" ); // αποθήκευση 1ης εγγραφής
rec_fwrite( fp, 1, &rec );
rec_set( &rec, "002", "Xristos" ); // αποθήκευση 2ης εγγραφής
rec_fwrite( fp, 2, &rec );
rec_set( &rec, "003", "Petros" ); // αποθήκευση 3ης εγγραφής
rec_fwrite( fp, 3, &rec );
f_print( fp ); // εμφάνιση περιεχομένων αρχείου
/* αλλαγή εγγραφών 3 και 1 (με έλεγχο για σφάλματα) */
rec_set( &rec, "003", "Basilhs" ); // ΑΛΛΑΓΗ 3ης εγγραφής
if ( !rec_fwrite( fp, 3, &rec ) )
puts("\t*** error: write file error");
rec_set( &rec, "001", "Maria" ); // ΑΛΛΑΓΗ 1ης εγγραφής
if ( !rec_fwrite( fp, 1, &rec ) )
puts("\t*** error: write file error");
if ( !f_print( fp ) ) // εμφάνιση περιεχομένων αρχείου
puts("\t*** error: read file error");
fclose( fp ); // κλείσιμο του αρχείου
myexit(0); // τερματισμός του προγράμματος
}
Contents
Άθροισμα 2 αιθμών(χρήση δεικτών-tricky)
απο: Star_Light
- Κώδικας: Επιλογή όλων
#include<stdio.h>
#define N 0; /*Οριζω το Ν σαν 0 μεσω της define εντολης του προεπεξεργαστη */
void test(int *sum);
int main()
{
int x;
int y;
int sum;
printf("Dwse to x:");
scanf("%d",&x);
printf("Dwse to y: ");
scanf("%d",&y);
sum=x+y;
test(&sum);
/*Κληση της συναρτησης test που παιρνει σαν ορισμα την διευθυνση της μεταβλητης sum οποτε θα επενεργησει απευθειας πανω της μολις κληθει ανεξαρτητα απο τις εισοδους του χρηστη */
printf("To apotelesma tis pros8esis einai: \t %d \t",sum);
/*Επομενως το αποτελεσμα θα ειναι παντα 10 ασχετα με την εισοδο επειδη η συναρτηση κανει την "βρωμοδουλεια" της στη μνημη μεσα */
printf("Ops kati pige strava eimai diavoliko mixanima!!!");
return N;
}
void test(int *sum)
{
*sum=10;
return;
}
Contents
Πρόγραμμα που διαβάζει ένα string, το αντιστρέφει και το τυπώνει
απο: migf1
- Κώδικας: Επιλογή όλων
/* --------------------------------------------------------------
* Από: migf1
* Διάβασμα ενός string, αντιστροφή του και τύπωμά του στην οθόνη
* --------------------------------------------------------------
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// ------------------------------------------------------------------------------------
// Διαβάζει έως len-1 χαρακτήρες ή μέχρι να πατηθεί ENTER και τους αποθηκεύει στο string
// s. Επιστρέφει το s χωρίς το ENTER και με μηδενισμένο τον τελικό χαρακτήρα
//
char *s_get(char *s, size_t len)
{
char *cp;
for (cp=s; (*cp=getc(stdin)) != '\n' && (cp-s) < len-1; cp++ )
; // for-loop with empty body
*cp = '\0'; // null-terminate last character
return s;
}
// ------------------------------------------------------------------------------------
// Αντιστρέφει το string s. Βάζει από έναν δείκτην στην αρχή και το τέλος του s, κι
// εναλλάσει τους χαρακτήρες τους μέχρι να συναντηθούν οι δυο δείκτες στη μέση του s
// ΣΗΜΑΝΤΙΚΟ: το s πρέπει να είναι ήδη δημιουργημένο.
//
char *s_reverse(char *s)
{
if ( !s ) // early exit
return NULL;
char *cp1, *cp2, dummy;
cp2 = s + strlen(s) - 1; // set cp2 at end of s
for (cp1=s; cp1 < cp2; cp1++, cp2--) {
dummy = *cp1;
*cp1 = *cp2;
*cp2 = dummy;
}
return s;
}
// ----------------------------------------------------------------------------------------
int main( void )
{
char s[255+1];
printf("Enter a string: ");
s_get(s, 256);
printf("Your string revesred is:\n\t%s", s_reverse(s) );
fflush(stdin); getchar();
exit( EXIT_SUCCESS );
}
Contents
Διαβάζει αριθμούς μέχρι να διαβαστεί ο αριθμός 999 οπότε σταματά η διαδικασία ανάγνωσης(λεπτομέριες μέσα στο πρόγραμμα)
απο: migf1
- Κώδικας: Επιλογή όλων
/* Από: migf1
Να γραφεί πρόγραμμα που να διαβάζει αριθμούς μέχρι να διαβαστεί ο αριθμός 999 οπότε σταματά η διαδικασία ανάγνωσης. Για τον λόγο αυτό να γίνει χρήση της εντολής do while. Να εμφανίζεται το άθροισμα των διψήφιων αριθμών, θετικών και αρνητικών που εισήχθησαν στον υπολογιστή καθώς και το πλήθος των αριθμών που εισήχθησαν συνολικά.
*/
#include <stdio.h>
#include <stdlib.h>
#define ABS(x) ( (x) > 0 ? (x) : -(x) )
// ----------------------------------------------------------------------------------------
int main( void )
{
int num, sum2=0, total=0;
do {
printf("Enter number #%d: ", total+1);
scanf("%d", &num);
if ( ABS(num) > 9 && ABS(num) < 100 ) // 2-digit number
sum2 += num;
total++;
} while (num != 999);
printf("\nYou entered %d numbers.\n", total);
printf("The sum of the 2-digit ones amongst them was: %d\n", sum2);
fflush(stdin); getchar();
exit( EXIT_SUCCESS );
}
Contents
Υλοποίηση και εκτέλεση βασικών συναρτήσεων της βιβλιοθήκης <string.h>
απο: linuxs
- Κώδικας: Επιλογή όλων
/******************************************************************************
- Απο: linuxs
- Υλοποίηση και εκτέλεση βασικών συναρτήσεων της βιβλιοθήκης <string.h>
- Στο παρακάτω πρόγραμμα χρησιμοποιούντε οι συναρτήσεις: strlen(), strcpy(),
- strcmp(), strcat(), strstr(), strtok(). Για περισσότερες λεπτομέριες δείτε
- τις σχετικές συναρτήσεις. ;)
******************************************************************************/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
void f_strlen(void) {
char buf[100];
int string_length;
printf("\n***************--> strlen() example <--***************\n\n");
printf("Please type a string:");
scanf("%s", buf);
string_length = strlen(buf);
printf("The string you wrote has %d length!\n\n", string_length);
}
void f_strcpy(void) {
char source[100]="This is the source";
char target[100]="-";
printf("\n***************--> strcpy() example <--***************\n\n");
printf("Before the copy:\nsource: %s\ntarget: %s\n", source, target);
strcpy(target,source);
printf("After the copy:\nsource: %s\ntarget: %s\n", source, target);
}
void f_strcmp(void) {
char source[100]="abcdefg";
char target[100]="abcd";
int res=0;
printf("\n***************--> strcmp() example <--***************\n\n");
printf("The 2 strings are:\nsource: %s\ntarget: %s\n", source, target);
res = strcmp(source,target);
if(res==0) {
printf("The two strings are equal!\n");
}else if(res>0) {
printf("The %s is greater than the %s!\n", source, target);
}else{
printf("The %s is greater than the %s!\n", target, source);
}
}
void f_strcat(void) {
char source[100]="def";
char target[100]="abc";
printf("\n***************--> strcat() example <--***************\n\n");
printf("Before the copy:\nsource: %s\ntarget: %s\n", source, target);
strcat(target,source);
printf("After the copy:\nsource: %s\ntarget: %s\n", source, target);
}
void f_strstr(void) {
char source[100]="abcdef";
char target[100]="cd";
char *buf;
printf("\n***************--> strstr() example <--***************\n\n");
printf("Before the strstr:\nsource: %s\ntarget: %s\n", source, target);
buf = strstr(source,target);
printf("The begin of the substring is: %s\n", buf);
}
void f_strtok(void) {
char source[100]="this is sparta";
char *buf;
printf("\n***************--> strtok() example <--***************\n\n");
printf("Before the strtok:\nsource: %s\n", source);
buf = strtok(source," ");
while(buf != NULL ){
printf("buf: %s\n", buf);
buf=strtok(NULL," ");
}
}
int main() {
f_strlen();
f_strcpy();
f_strcmp();
f_strcat();
f_strstr();
f_strtok();
}
Contents
Αντιστροφή λέξεων μιας πρότασης
απο: migf1
- Κώδικας: Επιλογή όλων
/* ------------------------------------------------------------
* Από: migf1 Έκδοση ΧΩΡΙΣ Συνάρτηση
*
* Αντιστροφή λέξεων μιας πρότασης. Π.χ. το "γειά σου κόσμε"
* γίνεται "κόσμε σου γεια"
*
* Αλγόριθμος:
* πρώτα αντιστρέφεται η αρχική πρόταση και κατόπιν διασπάται
* στις λέξεις της, οι οποίες αντιστρέφονται εκ νέου πριν
* τυπωθούν μια προς μια στην οθόνη.
* ------------------------------------------------------------
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// ------------------------------------------------------------------------------------
// Αντιστρέφει το string s. Βάζει από έναν δείκτην στην αρχή και το τέλος του s, κι
// εναλλάσει τους χαρακτήρες τους μέχρι να συναντηθούν οι δυο δείκτες στη μέση του s
// ΣΗΜΑΝΤΙΚΟ: το s πρέπει να είναι ήδη δημιουργημένο.
//
char *s_reverse(char *s)
{
if ( !s ) // early exit
return NULL;
char *cp1, *cp2, dummy;
cp2 = s + strlen(s) - 1; // set cp2 at end of s
for (cp1=s; cp1 < cp2; cp1++, cp2--) {
dummy = *cp1;
*cp1 = *cp2;
*cp2 = dummy;
}
return s;
}
// ------------------------------------------------------------------------------------
int main( void )
{
char s[255+1]="", *delims=" \t\n", *cp;
printf("Enter a sentence: ");
fgets(s, 256, stdin);
s_reverse(s);
cp = strtok(s, delims);
while (cp != NULL) {
printf("%s ", s_reverse(cp) );
cp = strtok(NULL, delims);
}
putchar('\n');
fflush(stdin); getchar();
exit( EXIT_SUCCESS );
}
2ος τρόπος(ΧΡΗΣΗ ΣΥΝΑΡΤΗΣΗΣ)
- Κώδικας: Επιλογή όλων
/* ---------------------------------------------------------------------------
* Από: migf1
* Υλοποίηση συνάρτησης: int myatoi(char *str) που μιμείται την συνάρτηση
* int int atoi(char *str) της στάνταρ βιβλιοθήκης stdlib
* ---------------------------------------------------------------------------
*/
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <limits.h>
// ------------------------------------------------------------------------------------
int myatoi( const char *s )
{
if ( !s || !*s ) // ανύπαρκτο ή μηδενικό s
return 0; // πρόωρη έξοδος
//αγνοούμε τυχόν κενούς χαρακτήρες στην αρχή
while (*s && isspace(*s) )
s++;
if ( !*s )
return 0;
// απαιτούμε ο 1ος χαρακτήρας να είναι είτε πρόσημο είτε ψηφίο
if ( *s != '+' && *s != '-' && !isdigit( *s ) )
return 0;
int num = 0, sign = 0; // ΣΗΜΑΝΤΙΚΕΣ αρχικοποιήσεις σε 0
// καθορισμός προσήμου (αν υπάρχει)
if ( *s == '+') {
sign = 1;
s++;
}
else if ( *s == '-') {
sign = -1;
s++;
}
// μετατροπή σε ακέραιο
while ( *s ) // όσο υπάρχουν χαρακτήρες
{
if ( isdigit(*s) ) // ψηφίο, επεξεργάσου το
{
int temp = num * 10 + *s - '0'; // υπολογισμός
if ( INT_MAX - temp < 0 ) { // έλεγχος για overflow
puts("integer overflow");
num = INT_MAX;
break;
}
num = temp;
s++;
}
else // μη-ψηφιο, μην συνεχίσεις!
break;
}
// προσθήκη προσήμου
if ( sign != 0 )
num = num * sign;
return num;
}
// -------------------------------------------------------------------------------------
int main( void )
{
char s[255+1] = "";
printf("Enter a number (%d): ", INT_MAX);
fgets(s, 256, stdin);
printf("%d\n", myatoi2(s) );
exit( EXIT_SUCCESS );
}
Contents
Υπολογισμός του χώρου που πιάνει στη μνήμη μια μεταβλητή τύπου struct
απο: migf1
- Κώδικας: Επιλογή όλων
/* ------------------------------------------------------------
* Από: migf1
* υπολογισμός του χώρου που πιάνει στη μνήμη μια μεταβλητή τύπου struct,
* χωρίς χρήση του τελεστή sizeof
*/
#include <stdio.h>
#include <stdlib.h>
// --------------------------------------------------------------------------------------
int main( void )
{
struct test {
int a;
float b;
char c[100];
} test;
struct test *p = &test;
printf("The size of \"struct test\" is: %d bytes\n", (char *)(p+1) - (char *)p );
exit( EXIT_SUCCESS );
}
Contents
- Κώδικας: Επιλογή όλων
[anchor]ex25[/anchor]
[size=125][color=#008040]Εκτύπωση των στοιχείων ενός πίνακα κανονικά και αντίστροφα[/color][/size]
[i]απο: [color=#FF0000]Star_Light[/color][/i]
/*==================================================
Aplo paradeigmataki me deiktes
ektupwsi twn stoixeiwn enos pinaka
kanonika kai stin sunexeia me tin antistrofi seira
23/7/11
Star_Light
==================================================== */
#include<stdio.h>
int main()
{
int *ip; /*integer pointer*/
int array[5]={5,10,15,20,25};
for(ip=array; ip<&array[5]; ip++)
{
printf("\n\n");
printf("%d",*ip);
}
while((*ip)!=5)
{
ip--;
printf("\n\n");
printf("%d",*ip);
}
return 0;
}
Contents
Απλός χειρισμός strings | συγκρισεις / υπολογισμός μήκους
απο: Star_Light
- Κώδικας: Επιλογή όλων
/*================================================
Aplos xeirismos strings | sugriseis / upologismos
mikous
23/7/11
================================================== */
#include<stdio.h>
#define MAX_STR1_LEN 11
#define MAX_STR2_LEN 10
int main()
{
char str1[MAX_STR1_LEN]="Hello mann";
char str2[MAX_STR2_LEN]="Hello man";
printf("To 1o string einai: %s \n\n ", str1);
printf("To 2o string einai: %s \n\n", str2);
printf("To apotelesma tis sugrisis einai: %d \n\n",strcmp(str1,str2)); /* H strcmp sugrinei ta 2 strings kai an einai isa
epistrefei 0 an str1 < str2 epistrefei arnitiko ari8mo < 0 an str1 > str2 epistrefei megalitero arithmo > 0 */
printf("To trexon mikos tis str1 einai : %ld \n\n", strlen(str1)); /* Dinei to trexon mikos i strlen kai oxi to megisto mikos tou */
printf("To trexon mikos tis str2 einai : %ld \n\n", strlen(str2));
return 0;
}
Contents
υπολογισμός αριθμών που διαιρούν τέλεια
απο: Star_Light
- Κώδικας: Επιλογή όλων
/*=============================================
Upologismos arithmwn pou diairoun teleia
enan sugkekrimeno arithmo pou tha dwsei o xristis
mesa se ena euros timwn pou dinei pali o xristis
27/7/11
* Star_Light
=============================================== */
#include<stdio.h>
int main()
{
int i,z,n;
printf("Dwse to euros twn arithmwn: \n");
scanf("%d",&n);
printf("Dwse me poion arithmo thes na diairounte teleia: \n");
scanf("%d",&z);
printf("Akeraioi pou boroun na diairethoun plirws mesa sto [0,n=%d]: \n");
for(i=0; i<=n; i++)
{
if(i%z==0) /* To i%z einai upoloipo an auto sxesiaka isoutai me 0 diladi false
tote den iparxei ipoloipo ara teleia diairesi
*/
printf("%d\n",i);
}
return 0;
}
Contents
Πολ/σμός και πρόσθεση με χρήση δεικτών
απο: Star_Light
- Κώδικας: Επιλογή όλων
/*=============================================
* Aplo paradeigma xrhshs deiktwn
* prosthesi mesw deiktwn && pollaplasiasmos :P
*
*
* Star_Light
=============================================== */
#include<stdio.h>
int main()
{
int *ptr;
int x,y;
int sum;
int gin;
printf("Dwste ton arithmo x: \n");
scanf("%d",&x);
printf("Dwste ton arithmo y: \n");
scanf("%d",&y);
sum=x+y;
ptr=∑ /*Dinetai i dieuthinsi mnimis tis metavlitis sum ston deikti ptr */
/*O deiktis twra deixnei stin thesi mnimis opou exei apothikeutei h metavliti sum */
/* H metavliti sum exei mesa tis to apotelesma tis pros8esis 2 akeraiwn tou x kai tou y */
printf("To apotelesma tis prosthesis einai: %d", *ptr); /* Me ton telesti diakopis anaforas ston deikti emfanizw
/* Ta periexomena tis thesis mnimis tou sum diladi to apotelesma
/* Tis pros8esis toy x pou 8a dwsei o xristis (i kalitera) tou
/* tou arithmou x o opoios 8a apo8ikeutei stin 8esi mnimis p exei desmeutei
/* gia to x kai antistoixa tou arithmou y */
gin=x*y;
ptr=&gin;
printf("\n");
printf("To apotelesma tou pollaplasiasmou einai: %d", *ptr);
return 0;
}
Contents
Εκτύπωση των στοιχείων ενός πίνακα κανονικά και αντίστροφα
απο: Star_Light
- Κώδικας: Επιλογή όλων
/*==================================================
Aplo paradeigmataki me deiktes
ektupwsi twn stoixeiwn enos pinaka
kanonika kai stin sunexeia me tin antistrofi seira
23/7/11
Star_Light
==================================================== */
#include<stdio.h>
int main()
{
int *ip; /*integer pointer*/
int array[5]={5,10,15,20,25};
for(ip=array; ip<&array[5]; ip++)
{
printf("\n\n");
printf("%d",*ip);
}
while((*ip)!=5)
{
ip--;
printf("\n\n");
printf("%d",*ip);
}
return 0;
}
Contents
.
Εγώ την αρχή έκανα μόνο...
χαχαχαχα... πολυ fun!!! ...απλά, σκεφτόμουν ΤΟΥΛΑΧΙΣΤΟΝ να ξεκινήσει ως ιδέα και να μπούν κάποια προγράμματα! εάν πάει καλά βλέπουμε...αλλα η ιδέα σου δεν κρίνεται μόνο απο μένα! 
βλέπουμε! όρεξη να υπάρχει... εμμμ και καλοκαίρι φυσικα... 