مشروع مكتبة اكواد

حسنا لا افهم ما المقصود من الموضوع، ما هى الاكواد المطالب منى ان اشارك بها؟! فكرة العنوان ليست واضحة فمن الأفضل مثلا ان نقوم بمشاركة بعضنا البعض بمشاريع بسيطة، او بعض الدوال التى نرى انها اذكى اكوادنا حتى الأن، اظن انك لم توضح :)

صحيح 100%

mr omer كتب:

السلام عليكم ايها الاخوة لطالما عانينا في ايجاد الاكواد الجديدة بالرغم من دراستنا العديد من الاكواد اذاً لما لا نضع الاكواد التي لدينا لتكون موسوعة للمبتدئين والحائرين كما لدينا مكتبة كتب السي++ يجب ان يكون لدينا مكتبة اكواد السي++ >>مشاركة الاكواد فيما بيننا وعرضها هنا<<

وشكرا

وعليكم السلام أخي عمر

أعتقد أنني فهمت فكرتك جيدا!!

أن نضع مثلا أكواد أو مشاريع تخصنا و نشارك أفكارنا مع الآخرين

فكرة جيدة!! :cool:

سأبدأ أولا بهذا المشروع البسيط في انتظار مشاريع و أكواد المبرمجين الآخرين

#include <stdio.h>
#include <stdlib.h>
#define  MAX  30

void   afficher  	(char *,const char *,const char *[27]);
void   alphabet  	(const char *(*)[27]);
void   pb_memoire	(void);
void   pb_whrite 	(void);
void   vider_buffer  (void);
size_t strlenght 	(char *);
size_t convertir 	(char *);
char * realloc_s 	(char **,size_t);
char * strchar   	(char *,char );
int	lire      	(char **);


int main()
{

int i=0;
const char *p[27]={NULL};
const char *azerty="ABCDEFGHIJKLMNOPQRSTUVWXYZ ";
char* intro=(char*) calloc(MAX,sizeof(char));
if(!intro)    	pb_memoire();
printf("introduisez un mot ou une phrase:\t");
if(!lire(&intro)) pb_whrite ();
intro  =  realloc_s (&intro,strlenght(intro));
if(!intro)    	pb_memoire();
intro[strlenght(intro)] = '\0';
intro=realloc_s (&intro,convertir(&intro));
if(!intro)    	pb_memoire();
alphabet(&p);
afficher(intro,azerty,p);
free(intro);
intro=0;

return 0;
}


void pb_memoire()
{
	puts("no memory");
	exit(0);
	return;
}

char *realloc_s(char **p,size_t n)
{
	char *q=(char*)realloc(*p,n*sizeof(char)+1);
	if(q)
	return q;
	else
	return 0;
}

size_t strlenght(char *intro)
{
	int	i=0;
	size_t n=0;
	while(intro[i++]) n++;
	return n;
}

size_t convertir( char * p)
{
	int	i=0;
	size_t j=0;
	for(;p;i++)
	{
      	if(p>=0x61 && p<=0x7a)
        	{
          	p^=0x20;
          	p[j++]=p;
        	}
      	else if((p>=0x41 && p<=0x5a)|| p==0x20)
        	{
          	p[j++]=p;
        	}
	}
	p[j]='\0';
	return j;
}

int lire(char **ch)

{
	char *q=NULL;
	if(fgets(*ch,MAX,stdin))
	{
  	q=strchar(*ch,'\n');
  	if(q)
  	{
      	*q='\0';
  	}
  	else
  	{
      	vider_buffer();
  	}
  	return  1;
	}

	else
	{
  	vider_buffer();
  	return 0;
	}
}

void vider_buffer()
{
	int c=0;
	while(c!='\n'&& c!=EOF)
	{
    	c=getchar();
	}
	return;
}

void afficher(char* intro,const char *azerty,const char *p[27])

{
	int i,j;
	puts("\n\n\n");
	for(i=0;i<strlenght(intro);i++)
 	{
  	for(j=0;j<27;j++)
   	if(intro==azerty[j])
    	{
     	puts(p[j]);
     	break;
    	}
 	}
	return;
}

void alphabet(const char *(*p)[27])

{

//A

(*p)[0]="         	***     	\n"
    	"        	*   *    	\n"
    	"        	*****    	\n"
    	"        	*   *    	\n"
    	"        	*   *    	\n\n\n";
//B

(*p)[1]="        	****     	\n"
    	"        	*   *    	\n"
    	"        	****     	\n"
    	"        	*   *    	\n"
    	"        	****     	\n\n\n";

//C

(*p)[2]="          	***\\  	\n"
    	"        	*        	\n"
    	"       	*         	\n"
    	"        	*        	\n"
    	"          	***/   	\n\n\n";

//D

(*p)[3]="        	*****    	\n"
    	"        	*	*   	\n"
    	"        	*	**  	\n"
    	"        	*	*   	\n"
    	"        	*****    	\n\n\n";
//E

(*p)[4]="        	*****    	\n"
    	"        	*        	\n"
    	"        	****     	\n"
    	"        	*        	\n"
    	"        	*****    	\n\n\n";

//F

(*p)[5]="        	*****    	\n"
    	"        	*        	\n"
    	"        	****     	\n"
    	"        	*        	\n"
    	"        	*        	\n\n\n";

//G

(*p)[6]="        	****\\   	\n"
    	"       	*         	\n"
    	"      	*   /***   	\n"
    	"       	* 	*   	\n"
    	"        	*****    	\n\n\n";

//H

(*p)[7]="        	*   *    	\n"
    	"        	*   *    	\n"
    	"        	*****    	\n"
    	"        	*   *    	\n"
    	"        	*   *    	\n\n\n";

//I

(*p)[8]="        	*****    	\n"
    	"          	*      	\n"
    	"          	*      	\n"
    	"          	*      	\n"
    	"        	*****    	\n\n\n";

//J

(*p)[9]="         	***     	\n"
    	"          	*      	\n"
    	"          	*      	\n"
    	"       	*  *      	\n"
    	"        	**       	\n\n\n";

//K

(*p)[10]="        	*   *   	\n"
     	"        	*  *    	\n"
     	"        	***     	\n"
     	"        	*  *    	\n"
     	"        	*   *   	\n\n\n";

//L

(*p)[11]="        	*       	\n"
     	"        	*       	\n"
     	"        	*       	\n"
     	"        	*       	\n"
     	"        	*****   	\n\n\n";

//M

(*p)[12]="       	* 	*  	\n"
     	"       	* * * *  	\n"
     	"       	*  *  *  	\n"
     	"       	* 	*  	\n"
     	"       	* 	*  	\n\n\n";

//N

(*p)[13]="       	**	*  	\n"
     	"       	* *   *  	\n"
     	"       	*  *  *  	\n"
     	"       	*   * *  	\n"
     	"       	*	**  	\n\n\n";

//O

(*p)[14]="        	*****   	\n"
     	"       	* 	*  	\n"
     	"       	* 	*  	\n"
     	"       	* 	*  	\n"
     	"        	*****   	\n\n\n";

//P

(*p)[15]="        	****    	\n"
     	"         	*  *   	\n"
     	"         	***    	\n"
     	"         	*      	\n"
     	"        	***     	\n\n\n";

//Q

(*p)[16]="        	*****   	\n"
     	"       	* 	*  	\n"
     	"       	*  *  *  	\n"
     	"       	*  ** *  	\n"
     	"        	*****   	\n"
     	"             	*  	\n\n\n";

//R

(*p)[17]="        	****    	\n"
     	"        	*   *   	\n"
     	"        	****    	\n"
     	"        	*  *    	\n"
     	"        	*   *   	\n\n\n";

//S

(*p)[18]="         	***\\  	\n"
     	"        	*       	\n"
     	"         	***    	\n"
     	"            	*   	\n"
     	"        	\\***   	\n\n\n";

//T

(*p)[19]="       	/*****\\ 	\n"
     	"          	*     	\n"
     	"          	*     	\n"
     	"          	*     	\n"
     	"          	*     	\n\n\n";

//U

(*p)[20]="       	* 	*  	\n"
     	"       	* 	*  	\n"
     	"       	* 	*  	\n"
     	"       	* 	*  	\n"
     	"        	*****   	\n\n\n";

//V

(*p)[21]="     	**   	**	\n"
     	"       	* 	*  	\n"
     	"        	*   *   	\n"
     	"         	* *    	\n"
     	"          	*     	\n\n\n";

//W

(*p)[22]="    	**     	**   \n"
     	"     	*     	*	\n"
     	"      	*   *   * 	\n"
     	"       	* * * *  	\n"
     	"        	*   *   	\n\n\n";

//X

(*p)[23]="      	** 	** 	\n"
     	"        	*   *   	\n"
     	"          	*     	\n"
     	"        	*   *   	\n"
     	"      	** 	** 	\n\n\n";

//Y

(*p)[24]="       	*	*\\ 	\n"
     	"        	*  *    	\n"
     	"         	++     	\n"
     	"         	*      	\n"
     	"        	*       	\n\n\n";

//Z

(*p)[25]="        	*****    	\n"
     	"       	/   *     	\n"
     	"          	*      	\n"
     	"         	*   /   	\n"
     	"        	*****    	\n\n\n";

// \t

(*p)[26]="\n\n\n\n\n\n";

return;
}

char * strchar(char *p,char ch)

{
	int i;
	for(i=0;p!='\0';i++)
   	if(p==ch)
      	break;

	if(p)
	return (p+i);
	else
	return 0;
}

void pb_whrite(void)

{
	puts("error whriting");
	exit(0);
	return;
}

فكرتي كانت أن نكتب جملة أو كلمة أو مجموعة أحرف و من تم إظهارها بشكلها الكبير :lol:

بالتوفيق!

1+ شكرا لمجهودك

اما هنا ففكرتي ان يدخل المستخدم عملية حسابية مثل(2 * 2 * / 5 + 4 - 3) ثم يعرض الناتج

#include <iostream>
#include <windows.h>
#include <conio.h>
#include <vector>
#include <string>

#define ADD '+'
#define SUB '-'
#define MUL '*'
#define DIV '/'
#define END '\r'
#define ADDVAULE 1
#define SUBVAULE 2
#define MULVAULE 3
#define DIVVAULE 4

//warnings
#define YAOF 100	 // may you add operation fou

//errors
#define YAFC 100     // you are add a fou char
#define YETOB 101    // you enter tou operation in begin
#define YEEOB 102    // you enter error operation in begin
#define YEMSE 103    // you enter multi symbol error
#define MCWSN 104	 // mul can't was symbol number
#define DCWSN 105	 // div can't was symbol number

using namespace std;

int enterInst();
int GetEqule();

struct Token
{
	Token(){type = 0;vaule = 0;}
	int type;
	int vaule;
};

char inst[255];
vector<Token> Tokens(0);
vector<int> Warnings(0);
vector<int> Errors(0);

//help func
void warning(int warningId)
{
	Warnings.push_back(warningId);
}
void error(int errorId)
{
	Errors.push_back(errorId);
}
void DisplayWarnings()
{
	if(Warnings.empty())
		cout << "no warnings";
	for(UINT i = 0;i < Warnings.size();i++)
	{
		switch(Warnings)
		{
		case YAOF:
			cout << endl << "may you add a operation fou";
			break;
		default:
			cout << endl << "a warning";
			break;
		}
	}
}
void DisplayErrors()
{
	if(Errors.empty())
		cout << "no errors";
	for(UINT i = 0;i < Errors.size();i++)
	{
		switch(Errors)
		{
		case YAFC:
			cout << endl << "you are add a fou char";
			break;
		case YETOB:
			cout << endl << "you enter multi symbol in begin";
			break;
		case YEEOB:
			cout << endl << "you enter error in begin";
			break;
		case YEMSE:
			cout << endl << "you are enter multi symbol error";
			break;
		case MCWSN:
			cout << endl << "mul can't was symbol number";
			break;
		case DCWSN:
			cout << endl << "div can't was symbol number";
			break;
		default:
			cout << endl << "a error";
			break;
		}
	}
}
void changeColor(DWORD color)
{
	HANDLE hstd = GetStdHandle(STD_OUTPUT_HANDLE);
	SetConsoleTextAttribute(hstd, color);
}

//function begin
//
//
void main()
{
	//1 blue dark
	//10 green
	//9 blue
	//12 red
	//5 vyoli
	//14 yallow
	//7 white
	//8 white-dark
	bool tryagain = false;
start:
	{
		cout << endl << "    Loading ...  " << endl;
		if(Tokens.size() > 0){
			Tokens.clear();
			Warnings.clear();
			Errors.clear();}

		system("cls");

		changeColor(10);
		cout << "Enter a instruct of operations : made of numbers and just + & - & * & /" << endl;
		changeColor(7);
		if(!enterInst())
		{
			changeColor(12);
			cout << endl << "errors :";
			DisplayErrors();
			changeColor(14);
			cout << endl << "warnings :";
			DisplayWarnings();
		}
		else
		{
			changeColor(1);
			cout << endl << "/*----------*\\end/*-----------*\\";
			changeColor(7);
			if(!GetEqule()){
				changeColor(12);
				cout << endl << "errors :";
				DisplayErrors();}
			changeColor(14);
			cout << endl << "warnings :";
			DisplayWarnings();
		}
		changeColor(10);
		bool whilework = true;
		while(whilework)
		{
			cout << endl << "are you want to try again ( y , n) ? ";
			char a = getch();
			if(a == 'y')
			{	whilework = false;
				tryagain = true;}
			else if(a == 'n')
			{	whilework = false;
				tryagain = false;}

		}

	}
	if(tryagain)
		goto start;


}

int enterInst()
{
	char c = 0;
	bool islong = false;
	string nowtoken;
	while(c = getch())
	{
		if(c == END)
		{
			if(islong)
			{
				Token t;
				t.type = 0;
				t.vaule = atoi(nowtoken.c_str());
				islong = false;
				Tokens.push_back(t);
				nowtoken.clear();
				nowtoken = c;
			}
			break;
		}
		else if(c >= '0' && c <= '9')
		{
			if(!islong)
			{
				if(*(nowtoken.c_str()) == ADD)
				{
					Token t;
					t.type = 1;
					t.vaule = ADDVAULE;
					Tokens.push_back(t);
					nowtoken.clear();

				}
				else if(*(nowtoken.c_str()) == SUB)
				{
					Token t;
					t.type = 1;
					t.vaule = SUBVAULE;
					Tokens.push_back(t);
					nowtoken.clear();
				}
				else if(*(nowtoken.c_str()) == MUL)
				{
					Token t;
					t.type = 1;
					t.vaule = MULVAULE;
					Tokens.push_back(t);
					nowtoken.clear();
				}
				else if(*(nowtoken.c_str()) == DIV)
				{
					Token t;
					t.type = 1;
					t.vaule = DIVVAULE;
					Tokens.push_back(t);
					nowtoken.clear();
				}
				islong = true;
				nowtoken = c;
			}
			else
			{
				nowtoken += c;
			}
			cout << c;
		}
		else if(c == ADD || c == SUB || c == MUL || c == DIV)
		{
			changeColor(12);
			if(c == ADD)
				changeColor(9);
			if(c == MUL)
				changeColor(1);
			if(c == DIV)
				changeColor(5);
			if(islong)
			{
				Token t;
				t.type = 0;
				t.vaule = atoi(nowtoken.c_str());
				Tokens.push_back(t);
				nowtoken.clear();
				nowtoken = c;
			}
			else
			{
				if(*(nowtoken.c_str()) == ADD)
				{
					warning(YAOF);
					Token t;
					t.type = 1;
					t.vaule = ADDVAULE;
					Tokens.push_back(t);
					nowtoken.clear();
				}
				if(*(nowtoken.c_str()) == SUB)
				{
					Token t;
					t.type = 1;
					t.vaule = SUBVAULE;
					Tokens.push_back(t);
					nowtoken.clear();
				}
				if(*(nowtoken.c_str()) == MUL)
				{
					Token t;
					t.type = 1;
					t.vaule = MULVAULE;
					Tokens.push_back(t);
					nowtoken.clear();
				}
				if(*(nowtoken.c_str()) == DIV)
				{
					Token t;
					t.type = 1;
					t.vaule = DIVVAULE;
					Tokens.push_back(t);
					nowtoken.clear();
				}
				nowtoken = c;
			}
			islong = false;
			cout << c;
			changeColor(7);
		}
		else if(c == ' ')
		{

			Token t;
			if(islong)
			{
				t.type = 0;
				t.vaule = atoi(nowtoken.c_str());
			} 
			else if(*(nowtoken.c_str()) == ADD && !islong)
			{
				t.type = 1;
				t.vaule = ADDVAULE;
			}
			else if(*(nowtoken.c_str()) == SUB && !islong)
			{
				t.type = 1;
				t.vaule = SUBVAULE;
			}
			else if(*(nowtoken.c_str()) == MUL && !islong)
			{
				t.type = 1;
				t.vaule = MULVAULE;
			}
			else if(*(nowtoken.c_str()) == DIV && !islong)
			{
				t.type = 1;
				t.vaule = DIVVAULE;
			}
			Tokens.push_back(t);
			islong = false;
			nowtoken.clear();
			cout << c;
		}
		else
		{
			//\b
			cout << "\a";
			Sleep(50);
		}
	}
	return TRUE;
}
int GetEqule()
{
	vector<int> vars(0);
	vector<int> operations(0);
	bool inst = false;
	int oldinst = 0;
	const bool var = 0;
	const bool op = 1;
	for(UINT i = 0;i < Tokens.size();i++)
	{
		if(Tokens.type == var && inst == var)
		{
			inst = op;
			oldinst = var;
			vars.push_back(Tokens.vaule);
		}
		else if(Tokens.type == op && inst == op)
		{
			inst = var;
			oldinst = Tokens.vaule;
			operations.push_back(Tokens.vaule);
		}
		else if(Tokens.type == op && inst == var)
		{
			if(oldinst == ADDVAULE)
			{
				operations.pop_back();
				operations.push_back(Tokens.vaule);
			}
			else if(oldinst == SUBVAULE)
			{
				operations.pop_back();
				if(Tokens.vaule == ADDVAULE)
					operations.push_back(SUBVAULE);
				else if(Tokens.vaule == SUBVAULE)
					operations.push_back(ADDVAULE);
			}
			else if(oldinst == MULVAULE)
			{
				if(Tokens.vaule == ADDVAULE)
				{
					operations.pop_back();
					operations.push_back(MULVAULE);
					inst = var;
					oldinst = op;
				}
				else if(Tokens.vaule == SUBVAULE)
				{
					if(Tokens[i+1].type == 0)
					{
						vars.push_back(-(Tokens[i+1].vaule));
						inst = op;
						oldinst = var;
						i++;
					}
					else
					{
						error(YEMSE);
						return false;
					}
				}
				else if(Tokens.vaule == MULVAULE)
				{
					error(MCWSN);
					return false;
				}
				else if(Tokens.vaule == DIVVAULE)
				{
					error(DCWSN);
					return false;
				}

			}
			else if(oldinst == DIVVAULE)
			{
				if(Tokens.vaule == ADDVAULE)
				{
					operations.pop_back();
					operations.push_back(DIVVAULE);
					inst = var;
					oldinst = op;
				}
				else if(Tokens.vaule == SUBVAULE)
				{
					if(Tokens[i+1].type == 0)
					{
						vars.push_back(-(Tokens[i+1].vaule));
						inst = op;
						oldinst = var;
						i++;
					}
					else
					{
						error(YEMSE);
						return false;
					}
				}
				else if(Tokens.vaule == MULVAULE)
				{
					error(MCWSN);
					return false;
				}
				else if(Tokens.vaule == DIVVAULE)
				{
					error(DCWSN);
					return false;
				}

			}
			else
			{
				if(Tokens.vaule == SUBVAULE && Tokens[i+1].type == var)
				{
					vars.push_back(-(Tokens[i+1].vaule));
					inst = op;
					oldinst = var;
					i++;
				}
				else if(Tokens.vaule == SUBVAULE && Tokens[i+1].type == op)
				{
					error(YETOB);
					return false;
				}
				else
				{
					error(YEEOB);
					return false;
				}

			}

		}
	}

	if(vars.size()		 <= 1)
		return false;
	if(operations.size() <= 0)
		return false;
	int opsize = operations.size();
	int index = 0;
	for(UINT i = 0;i < opsize;i++)///////////////////////////////
	{
		if(operations[(i-index)] == MULVAULE || operations[(i-index)] == DIVVAULE)
		{
			int operation = operations[(i-index)];
			int mule = vars[(i-index)] * vars[(i+1-index)];
			int dive = vars[(i-index)] / vars[(i+1-index)];
			vector<int>::iterator ioperations = operations.begin();
			vector<int>::iterator ivars		  =		  vars.begin();
			operations.erase(ioperations+(i-index));
			vars.erase(ivars+(i-index));
			vars.erase(ivars+(i-index));
			if(operation == MULVAULE)
			{
				if((i-index) >= vars.size())
					vars.push_back(mule);
				else
					vars.insert(ivars+(i-index),mule);
			}
			else if(operation == DIVVAULE)
			{
				if((i-index) >= vars.size())
					vars.push_back(dive);
				else
					vars.insert(ivars+(i-index),dive);
			}
			index++;
		}
	}

	int equle = vars[0];

	for(UINT j = 0;j < operations.size();j++)
	{
		if(operations[j] == ADDVAULE)
			equle += vars[j+1];
		if(operations[j] == SUBVAULE)
			equle -= vars[j+1];
	}
	cout << endl << "this instruct equle: " << equle  ;
	return true;
}

ملاحظة لا اجيد الإنجليزية كثيرا

شكرا 1+

ماشاءء الله تباركك الله , موفق يارب