#include <stdio.h>
#define USER_DEFINED_BUFFER_SIZE 256
void main( void )
{
FILE *InputFilePtr,
*OutputFilePtr;
float FloatData;
char ProgramControlledBuffer[ USER_DEFINED_BUFFER_SIZE ];
InputFilePtr = fopen( "a:\\test.dat" , "r" );
OutputFilePtr = fopen( "a:\\outfil.dat", "w" );
if( setvbuf(InputFilePtr, ProgramControlledBuffer,
_IOFBF, USER_DEFINED_BUFFER_SIZE) != 0 )
printf("InputFilePtr buffer allocation error\n");
else
printf("InputFilePtr buffer created\n");
if ( setvbuf(OutputFilePtr, NULL, _IOLBF, 256) != 0 )
printf("OutputFilePtr buffer allocation error\n");
else
printf("OutputFilePtr buffer created\n");
while( fscanf( InputFilePtr,"%f",&FloatData ) != EOF )
fprintf(OutputFilePtr,"%f\n",FloatData);
fclose( InputFilePtr );
fclose( OutputFilePtr );
}#include <stdio.h>
char UserDefinedOutputBuffer[ BUFSIZ ];/* BUFSIZ в stdio.h */
void main( void )
{
setbuf( stderr, UserDefinedOutputBuffer );
fputs ( "Any information can now be sent to the\n",stderr );
fputs ( "\"UserDefinedOutputBuffer.\"\n" ,stderr );
fflush( stderr );
}#include <stdio.h>
#include <string.h>
#define ONE 1
#define FORTY 40
#define DESCRIPTION_LENGTH 81
#define IN_STOCK 1
#define OUT_OF_STOCK 0
#define NUMBER_OF_RECORDS_TO_READ 1
typedef struct product {
int ProductID,
IsAvailable;
float Price;
char Description[ DESCRIPTION_LENGTH ];
} PRODUCT;
void main( void )
{
FILE * InputFilePtr;
PRODUCT CurrentProduct;
int index,
ProductToSearchFor;
long FileOffset;
InputFilePtr = fopen( "a:// product.fil","w+" );
for(index = ONE; index <= FORTY; index++) {
CurrentProduct.ProductID = index;
CurrentProduct.IsAvailable = OUT_OF_STOCK;
fwrite( &CurrentProduct, sizeof(PRODUCT), 1, InputFilePtr);
}
printf("Enter Product ID: ");
scanf("%d", &ProductToSearchFor);
FileOffset = ( ProductToSearchFor - 1) * sizeof( PRODUCT );
fseek( InputFilePtr, FileOffset, 0 );
fread( &CurrentProduct, sizeof(PRODUCT), NUMBER_OF_RECORDS_TO_READ,
InputFilePtr );
fclose( InputFilePtr );
}#include <stdio.h>
void main( void )
{
int int_Data = 5555 ;
double double_Data = 1.4578109 ;
char c = 'c' ,
SampleString_1[] = "The fundamental things apply as ",
SampleString_2[] = "time goes bye..." ;
/* ============== автоматические преобразования типов =============== */
/* Строка номер 1: выводит символ c */
printf("\nLine Number %2d: %c",1,c);
/* Строка номер 2: выводит ASCII-код символа c */
printf("\nLine Number %2d: %d",2,c);
/* Строка номер 3: выводит символ, ASCII-код которого равен 90 */
printf("\nLine Number %2d: %c",3,90);
/* Строка номер 4: выводит int_Data в виде восьмеричного значения */
printf("\nLine Number %2d: %o",4,int_Data);
/* Строка номер 5: выводит шестнадцатеричное значение в младшем регистре */
printf("\nLine Number %2d: %x",5,int_Data);
/* Строка номер 6: выводит шестнадцатеричное значение в старшем регистре */
printf("\nLine Number %2d: %X",6,int_Data);
/* ======= возможности форматирования и преобразования данных ====== */
/* Строка номер 7: минимальная ширина 1 */
printf("\nLine Number %2d: %c",7,c);
/* Строка номер 8: минимальная ширина 5, выравнивание вправо */
printf("\nLine Number %2d: %5c",8,c);
/* Строка номер 9: минимальная ширина 5, выравнивание влево */
printf("\nLine Number %2d: %-5c",9,c);
/* Строка номер 10: автоматически определяемая ширина строки = 33 */
printf("\nLine Number %d: %s",10,SampleString_1);
/* Строка номер 11: автоматически определяемая ширина строки = 17 */
printf("\nLine Number %d: %s",11,SampleString_2);
/* Строка номер 12: ширина 5 задана вместо автоматически определяемого значения 33 */
printf("\nLine Number %d: %5s",12,SampleString_1);
/* Строка номер 13: минимальная ширина 38, выравнивание вправо */
printf("\nLine Number %d: %38s",13,SampleString_1);
/* Строка номер 14: минимальная ширина 38, выравнивание влево */
printf("\nLine Number %d: %-38s",14,SampleString_2);
/* Строка номер 15: выводит int_Data с шириной, по умолчанию равной 4 */
printf("\nLine Number %d: %d",15,int_Data);
/* Строка номер 16: выводит int_Data со знаком */
printf("\nLine Number %d: %+d",16,int_Data);
/* Строка номер 17: задана ширина 3 вместо автоматической 4 */
printf("\nLine Number %d: %3d",17,int_Data);
/* Строка номер 18: минимальная ширина 10, выравнивание вправо */
printf("\nLine Number %d: %10d",18,int_Data);
/* Строка номер 19: минимальная ширина по умолчанию 1, выравнивание влево */
printf("\nLine Number %d: %-d",19,int_Data);
/* Строка номер 20: выравнивание вправо с начальными нулями */
printf("\nLine Number %d: %010d",20,int_Data);
/* Строка номер 21: использование числа цифр, заданного по умолчанию */
printf("\nLine Number %d: %f",21,double_Data);
/* Строка номер 22: минимальная ширина 20, выравнивание вправо */
printf("\nLine Number %d: %20f",22,double_Data);
/* Строка номер 23: выравнивание вправо с начальными нулями */
printf("\nLine Number %d: %020f",23,double_Data);
/* Строка номер 24: минимальная ширина 20, выравнивание влево */
printf("\nLine Number %d: %-20f",24,double_Data);
/* Строка номер 25: выравнивание влево с конечными нулями */
printf("\nLine Number %d: %-020f",25,double_Data);
/* Строка номер 26: минимальная ширина 19, выводит все 19 символов */
printf("\nLine Number %d: %19.19s",26,SampleString_1);
/* Строка номер 27: выводит первые 2 символа */
printf("\nLine Number %d: %.2s",27,SampleString_1);
/* Строка номер 28: выводит два символа, выравнивание вправо */
printf("\nLine Number %d: %19.2s",28,SampleString_1);
/* Строка номер 29: выводит два символа, выравнивание влево */
printf("\nLine Number %d: %-19.2s",29,SampleString_1);
/* Строка номер 30: использует параметры форматирования */
printf("\nLine Number %d: %*.*s",30,19,6,SampleString_1);
/* Строка номер 31: ширина 10, 8 символов после '.' */
printf("\nLine Number %d: %10.8f",31,double_Data);
/* Строка номер 32: ширина 20, 2; выравнивание вправо */
printf("\nLine Number %d: %20.2f",32,double_Data);
/* Строка номер 33: 4 позиции после точки, выравнивание влево */
printf("\nLine Number %d: %-20.4f",33,double_Data);
/* Строка номер 34: 4 позиции после точки, выравнивание вправо */
printf("\nLine Number %d: %20.4f",34,double_Data);
/* Строка номер 35: ширина 20, экспоненциальная запись */
printf("\nLine Number %d: %20.2e",35,double_Data);
}#include <stdio.h>
#include <stdlib.h>
#define TWENTY 20
int main( void )
{
int An_int,
offset,
ArrayOfTWENTY_ints[TWENTY];
FILE * InputFilePtr;
InputFilePtr = fopen( "a:\\integer.dat", "wb" );
if( !InputFilePtr ) {
printf("The file integer.dat could not be found.");
exit( EXIT_FAILURE );
}
for( offset = 0; offset < TWENTY; offset++ ) {
ArrayOfTWENTY_ints[ offset ] = offset + 1;
putw(ArrayOfTWENTY_ints[ offset ], InputFilePtr);
}
fclose( InputFilePtr );
InputFilePtr = fopen( "a:\\integer.dat", "rb" );
if( !InputFilePtr ) {
printf("The file integer.dat could not be found.");
exit( EXIT_FAILURE );
}
An_int = getw( InputFilePtr );
while( !feof(InputFilePtr) ) {
printf("%3d",An_int);
An_int = getw( InputFilePtr );
}
return( EXIT_SUCCESS );
}InputOutputFilePtr=fopen("a:\\char.dat","rt+");
char_Data = fgetc( InputOutputFilePtr );
putchar( char_Data );
char_Data = fgetc( InputOutputFilePtr );
putchar( char_Data );
NumberOfBytesFromBeginningOfFile =
ftell( InputOutputFilePtr );
char_Data = fgetc( InputOutputFilePtr );
putchar( char_Data );
fseek( InputOutputFilePtr,
NumberOfBytesFromBeginningOfFile, 0);
char_Data = fgetc( InputOutputFilePtr );
putchar( char_Data );
fseek( InputOutputFilePtr,
NumberOfBytesFromBeginningOfFile, 0);
fputc('e',InputOutputFilePtr);
fseek( InputOutputFilePtr,
NumberOfBytesFromBeginningOfFile, 0);
char_Data = fgetc( InputOutputFilePtr );
putchar( char_Data );
rewind( InputOutputFilePtr );
char_Data = fgetc( InputOutputFilePtr );
putchar( char_Data );
}
#include <stdio.h>
typedef int whole;
typedef float real;
void main( void )
{
whole WholeNumber = 512;
real RealNumber = 3.14159;
printf("The whole value is %d: \n", WholeNumber);
printf("The real value is %f : \n", RealNumber );
}
#include <stdio.h>
#define NULL_STRING_TERMINATOR 1
#define MAX_VALID_CHARS 65
#define MAX_HOUSES 10
struct house_tag {
char owner [ MAX_VALID_CHARS + NULL_STRING_TERMINATOR ],
street[ MAX_VALID_CHARS + NULL_STRING_TERMINATOR ],
city [ MAX_VALID_CHARS + NULL_STRING_TERMINATOR ];
int bedrooms;
float price;
};
void main( void )
{
struct house_tag House_Catalog[ MAX_HOUSES ], *A_House_Ptr = House_Catalog;
int Which_House;
float float_bug_fix;
for( Which_House = 0; Which_House < MAX_HOUSES; Which_House++ ) {
printf("Who currently owns the house? ");
gets(A_House_Ptr->owner);
printf("\nThe house is on which street? ");
gets(House_Catalog[ Which_House ].street);
printf("\nThe house is in which city? ");
gets(A_House_Ptr->city);
printf("\nThe house has how many bedrooms? ");
scanf("%d", &A_House_Ptr->bedrooms);
printf("\nWhat is the selling price? ");
scanf("%f", &float_bug_fix);
A_House_Ptr->price = float_bug_fix;
A_House_Ptr++;
printf("\n\n");
flushall();
}
A_House_Ptr = House_Catalog;
for( Which_House = 0; Which_House < MAX_HOUSES; Which_House++ ) {
printf("\f");
printf("================ HOUSE 1 ================ "
"\nOwner:\t\t%25s"
"\nStreet:\t\t%25s"
"\nCity:\t\t%25s"
"\nBedrooms:\t%25d"
"\nPrice:\t\t%25.2f",
A_House_Ptr->owner, A_House_Ptr->street,
A_House_Ptr->city, A_House_Ptr->bedrooms,
A_House_Ptr->price);
A_House_Ptr++;
}
}#include <stdio.h>
#define NULL_STRING_TERMINATOR 1
#define MAX_VALID_CHARS 65
struct house_tag {
char owner [ MAX_VALID_CHARS + NULL_STRING_TERMINATOR ],
street[ MAX_VALID_CHARS + NULL_STRING_TERMINATOR ],
city [ MAX_VALID_CHARS + NULL_STRING_TERMINATOR ];
int bedrooms;
float price;
} A_House;
void main( void )
{
printf("Who currently owns the house? ");
gets(A_House.owner);
printf("\nThe house is on which street? ");
gets(A_House.street);
printf("\nThe house is in which city? ");
gets(A_House.city);
printf("\nThe house has how many bedrooms? ");
scanf("%d", &A_House.bedrooms);
printf("\nWhat is the selling price? ");
scanf("%f", &A_House.price);
printf("\f");
printf("================ HOUSE 1 ================"
"\nOwner:\t\t%25s"
"\nStreet:\t\t%25s"
"\nCity:\t\t%25s"
"\nBedrooms:\t%25d"
"\nPrice:\t\t%25.2f",
A_House.owner,A_House.street,A_House.city,
A_House.bedrooms,A_House.price);
}#include <stdio.h>
#define NULL_STRING_TERMINATOR 1
#define MAX_VALID_CHARS 65
struct house_tag {
char owner [ MAX_VALID_CHARS + NULL_STRING_TERMINATOR ],
street[ MAX_VALID_CHARS + NULL_STRING_TERMINATOR ],
city [ MAX_VALID_CHARS + NULL_STRING_TERMINATOR ];
int bedrooms;
float price;
} A_House;
void Print_A_House( struct house_tag Local_A_House );
void main( void )
{
printf("Who currently owns the house? ");
gets(A_House.owner);
printf("\nThe house is on which street? ");
gets(A_House.street);
printf("\nThe house is in which city? ");
gets(A_House.city);
printf("\nThe house has how many bedrooms? ");
scanf("%d", &A_House.bedrooms);
printf("\nWhat is the selling price? ");
scanf("%f", &A_House.price);
Print_A_House( A_House );
}
void Print_A_House( struct house_tag Local_A_House )
{
printf("\f");
printf("================ HOUSE 1 ================ "
"\nOwner:\t\t%25s"
"\nStreet:\t\t%25s"
"\nCity:\t\t%25s"
"\nBedrooms:\t%25d"
"\nPrice:\t\t%25.2f",
Local_A_House.owner,Local_A_House.street,
Local_A_House.city,Local_A_House.bedrooms,
Local_A_House.price);
}#include <stdio.h>
#define NULL_STRING_TERMINATOR 1
#define MAX_VALID_CHARS 65
#define MAX_HOUSES 10
struct house_tag {
char owner [ MAX_VALID_CHARS + NULL_STRING_TERMINATOR ],
street[ MAX_VALID_CHARS + NULL_STRING_TERMINATOR ],
city [ MAX_VALID_CHARS + NULL_STRING_TERMINATOR ];
int bedrooms;
float price;
};
void main( void )
{
struct house_tag House_Catalog[ MAX_HOUSES ];
int Which_House;
float float_bug_fix; /* для обхода недостатка компилятора, который не
* позволяет читать плавающие члены непосредственно */
for( Which_House = 0; Which_House < MAX_HOUSES;
Which_House++ ) {
printf("Who currently owns the house? ");
gets(House_Catalog[ Which_House ].owner);
printf("\nThe house is on which street? ");
gets(House_Catalog[ Which_House ].street);
printf("\nThe house is in which city? ");
gets(House_Catalog[ Which_House ].city);
printf("\nThe house has how many bedrooms? ");
scanf("%d", &House_Catalog[ Which_House ].bedrooms);
printf("\nWhat is the selling price? ");
scanf("%f", &float_bug_fix);
House_Catalog[ Which_House ].price = float_bug_fix;
printf("\n\n");
flushall();
}
for( Which_House = 0; Which_House < MAX_HOUSES;
Which_House++ ) {
printf("\f");
printf("================ HOUSE 1 ================ "
"\nOwner:\t\t%25s"
"\nStreet:\t\t%25s"
"\nCity:\t\t%25s"
"\nBedrooms:\t%25d"
"\nPrice:\t\t%25.2f",
House_Catalog[ Which_House ].owner,
House_Catalog[ Which_House ].street,
House_Catalog[ Which_House ].city,
House_Catalog[ Which_House ].bedrooms,
House_Catalog[ Which_House ].price);
}
} case 'l': A_long_Ptr = malloc( sizeof( long ) );
printf("\nEnter a long: ");
scanf("%ld", A_long_Ptr);
AnyDataType( A_long_Ptr, WhichType );
break;
case 'd': A_double_Ptr = malloc( sizeof ( double ) );
printf("\nEnter a double: ");
scanf("%lf", A_double_Ptr);
AnyDataType( A_double_Ptr, WhichType );
}
return 0;
}
void AnyDataType(void *DynamicData, char DataType)
{
switch( DataType ) {
case 's': printf("\nString type output: %s", (char *) DynamicData);
break;
case 'l': printf("\nLong type output: %ld", *(long *) DynamicData);
break;
case 'd': printf("\nDouble type output: %lf", *(double *) DynamicData);
break;
}
free( DynamicData );
}
#include <stdio.h>
#include <string.h>
int main ( void )
{
char *stack = "1 2 3 4 5 6";
int offset ;
for( offset = (strlen(stack)-1); offset >= 0; offset-- )
printf("%c", stack[ offset ]);
printf("\n%s", stack);
return( 0 );
}#include <stdio.h>
#include <ctype.h>
#define FOUR 4
char *ErrorMessageArray[ FOUR ] =
{
"\nFile Creation Error! \n",
"\nNot a character value! \n",
"\nNot an octal value! \n",
"\nIllegal punctuation! \n"
};
void FileCreate ( char *FileName );
char InputChar ( void );
int InputOctal ( void );
int Valid ( void );
FILE *FILE_structure_ptr;
int main( void )
{
char charData;
int intData;
FileCreate( "anyfile.dat" );
charData = InputChar();
intData = InputOctal();
charData = Valid();
return 0;
}
void FileCreate( char *FileName )
{
const FileCreationErrorMsg = 0;
FILE_structure_ptr = fopen( FileName,"r" );
if( !FILE_structure_ptr )
printf("%s",ErrorMessageArray[ FileCreationErrorMsg ]);
}
char InputChar( void )
{
char charData;
const NotCharDataErrorMsg = 1;
printf("\nEnter a character: ");
scanf("%c",&charData);
if( !isalpha( charData ) )
printf("%s",ErrorMessageArray[ NotCharDataErrorMsg ]);
return( charData );
}
int InputOctal( void )
{
int intData;
const NotOctalDataErrorMsg = 2;
printf("\nEnter an integer between 0 and 7: ");
scanf("%d",&intData);
if( (intData < 0) || (intData > 7) )
printf("%s",ErrorMessageArray[ NotOctalDataErrorMsg ]);
return( intData );
}
int Valid( void )
{
char charData;
const ContainsIllegalPunctuationErrorMsg = 3;
printf("\nEnter a punctuation symbol: ");
scanf(" %c",&charData);
if( !ispunct( charData ) )
printf("%s",ErrorMessageArray
[ ContainsIllegalPunctuationErrorMsg ]);
return( charData );
}