#ifndef HEADER_H

#define HEADER_H

#endif

#define HEADERNAME_H

#include <iostream>

using namespace std;

void helloworld()

{

    cout<<"Hello World!"<<endl;

}

#include "header2.h"

void sayhello()

{

    helloworld();

}

#include "header1.h"

int main(){

   sayhello();

   return 0;

}

#include "header2.h"

#include "header1.h"

#include "header2.h"

int main(){

   sayhello();

   return 0;

}

`void helloworld()

#ifndef HEADER2_H

#define HEADER2_H

#include <iostream>

using namespace std;

void helloworld()

{

    cout<<"Hello World!"<<endl;

}

#endif

#ifndef HEADER1_H

#define HEADER1_H

#include "header2.h"

void sayhello()

{

    helloworld();

}

#endif

#include "header1.h"

#include "header2.h"

int main(){

   sayhello();

   return 0;

}

#include "header1.h"

#include "header2.h"

#include "header1.h"

#include "header2.h"

#include "header1.h"

#include "header2.h"

#include "header1.h"

#include "header2.h"

int main(){

   sayhello();

   return 0;

}

این همه تایپ

ده
بازم میگم  فق

#include <cstdio>

struct M{
    M& operator<<(const char* in)
    {
        printf("%s",in);
        return *this;
    }
    M& operator<<(int in)
    {
        printf("%d",in);
        return *this;
    }
    M& operator<<(char in)
    {
        printf("%c",in);
        return *this;
    }

}myout;
const char el = '\n';

int main(){
   myout<<"Hello! "<<10<<el;
   return 0;
}

#include <iostream>

#include <stdarg.h>

using namespace std;

//! جمع اعدادی که براش میفرستیم رو برمیگردونه

//! count همون تعداد آرگومان هایی که براش میفرستیم

//! ... همون آرگومان بی نهایت

int FOO(int count,...)

{

    int out=0;//خروجی

    va_list args;// باید آرگومان ها رو توی این بریزیم

    va_start(args,count);// آرگومان ها رو توی اون میریزیم

    //count

    // نقطه شروع هست نه تعداد اشتباه نکنید

    for(int i=0;i<count;i++)//این حلقه به تعداد آرگومان ها اجرا میشه

    {

        int a = va_arg(args,int);//متغیر بعدی رو به عنوان عدد صحیح لود میکنیم

        out+=a;// به خروجی اضافه میکنیم

    }

    va_end(args);//تموم شد

    return out;

}

int main(){

   cout<<FOO(6,2,3,2,3,4,5)<<endl;//2+3+2+3+4+5=19

   return 0;

}

FOO(8,2,3,2,3,4,5)

#define CountArgs(...)

اول یه ماکرو مینویسیم تا تعدادش رو بشماریم

#define CountArgs(...) CountArgs2( (__VA_ARGS__,10,9,8,7,6,5,4,3,2,1) )

#define CountArgs2(args) CountArgs3 args

#define CountArgs3(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,argsc,...) argsc

cout<<CountArgs(1,1,1,1,1)<<endl;//5

CountArgs(1,1,1,1,1)

CountArgs2( (1,1,1,1,10,9,8,7,6,5,4,3,2,1) ) // دوتا پرانتز

CountArgs2(args) CountArgs3 args

CountArgs2(args) CountArgs3 (1,1,1,1,10,9,8,7,6,5,4,3,2,1) //args جابه جا میشه

CountArgs3(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,argsc,...) argsc

CountArgs3(1,1,1,1,1,10,9,8,7,6,5 ,...) argsc  // غیره ش رو ننوشتم دیگه احتیاجی نیست

argc نیتجه ی 5 رو تحویلمون میده

#define MYARGCOUNTER(...) CountArgs(__VA_ARGS__),__VA_ARGS__

cout<<FOO(MYARGCOUNTER(2,3,2,3,4,5))<<endl;

ل میکنه
#define CountArgs(...) CountArgs2(__VA_ARGS__,10,9,8,7,6,5,

,3,2,1)
#define CountArgs2(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,argsc,..

#include <iostream>

#include <cmath>

using namespace std;

template <typename T>

T Foo(T in) // یه تابع که عدد میگیره و دوبرابرش رو برمیگردونه

{

    return in *((T)2.0f);

}

int main()

{

    int a = 50;

    cout<<Foo(a)<<endl;

    return 0;

}

int *a = new int(50);

    cout<<Foo(a)<<endl;

#include <iostream>

#include <cmath>

#include <type_traits>

using namespace std;

template <typename T>

T Foo(T in)

{

    static_assert(!is_pointer<T>::value,"haaji az pointer estefade nakon!");

    return in *((T)2.0f);

}

int main()

{

    int *a=new int(50);

    cout<<Foo(a)<<endl;

    return 0;

}

int *a=new int(50);

    cout<<Foo(*a)<<endl;

#include <iostream>

#include <cmath>

#include <type_traits>

#include <string>

using namespace std;

template <typename T>

T Foo(T in)

{

    static_assert(!is_pointer<T>::value,"haaji az pointer estefade nakon!"); //ارور استفاده از اشاره گر

    static_assert(!is_same<T,string>::value,"haaji az string estefade nakon!");// ارور استفاده از استرینگ

    return in *((T)2.0f);

}

int main()

{

    string a;

    cout<<Foo(a)<<endl;

    return 0;

}

template <typename T>

T Foo(T in)

{

    static_assert(!is_pointer<T>::value,"haaji az pointer estefade nakon!");

    static_assert((is_same<T,int>::value||is_same<T,double>::value||is_same<T,float>::value),

                  "haaji faghat az int | double |float  estefade kon!");

    return in *((T)2.0f);

}

int main()

{

    int a=10;

    cout<<Foo(a)<<endl;

    return 0;

}

class A
{
public:
    A(){cout<<"Created!"<<endl;}
    ~A(){cout<<"removed!"<<endl;}
    void sayhello(){cout<<"hello!"<<endl;}
};

int main()
{
    {
        A* a = new A;
        A* b = new A;
        a->sayhello();
        b->sayhello();
        delete a;
        delete b;
    }
    return 0;
}

template<typename T>
class MyPointer
{
public:
    MyPointer(T* in):
        data(in)// اشاره گره
    {
    }
    MyPointer(MyPointer<T>& other){}
    ~MyPointer()
    {
        delete data;// حزف کردنش
    }
private:
    T* data;// همون اشاره گره
};

int main()
{
    {
        MyPointer<A> a(new A);
    }
    return 0;
}

operator T*(){return data;}
    operator const T*()const{return data;}

MyPointer<A> a(new A);
        ((A*)a)->sayhello();

T* operator -> (){return data;}

MyPointer<A> a(new A);
        a->sayhello();

MyPointer<A> b(new A[2]);
        b->sayhello();

template<typename T>
class MyPointer
{
public:
        MyPointer(T* in,unsigned int size=1):// سایز رو براش میفرستیم . اگه نفرستادیم برابر یک میشه یعنی اشاره گر به آرایه نیست
        data(in),
        isarray(size>1)// مشخص میکنیم اشاره گر به آرایه هست یا نه
    {
    }
    MyPointer(MyPointer<T>& other){}
    ~MyPointer()
    {
        if(isarray)// اگه اشاره گر به آرایه بود
            delete[] data;
        else
            delete data;
    }

    operator T*(){return data;}
    operator const T*()const{return data;}

    T* operator -> (){return data;}
private:
    T* data;
    bool isarray;// آیا اشاره گر به آرایه هست
};

MyPointer<A> b(new A[2],2);
        b->sayhello();

MyPointer<A> b(new A[2],2);
        ((A*)b)[1].sayhello();

T& operator[] (int in){ return data[in];}
    const T& operator[](int in)const{return data[in];}

template<typename T>
class MyPointer
{
public:
    MyPointer(T* in,int size=1):
        data(in),
        isarray(size>1)
    {
    }
    MyPointer(MyPointer<T>& other){}
    ~MyPointer()
    {
        if(isarray)
            delete[] data;
        else
            delete data;
    }

    operator T*(){return data;}
    operator const T*()const{return data;}

    T* operator -> (){return data;}

    T& operator[] (int in){ return data[in];}
    const T& operator[](int in)const{return data[in];}
private:
    T* data;
    bool isarray;
};


class A
{
public:
    A(){cout<<"Created!"<<endl;}
    ~A(){cout<<"removed!"<<endl;}
    void sayhello(){cout<<"hello!"<<endl;}
};

int main()
{
    {
        MyPointer<A> a(new A);
        MyPointer<A> b(new A[2],2);
        a->sayhello();
        b[0].sayhello();
        b[1].sayhello();
    }
    return 0;
}

#include <stdexcept>
using namespace std;

#define MYERROR( errormessage ) {char _errormessage[1000];sprintf(_errormessage,"\n\tError!!!\n\tFile=\"%s\"\n\tFunction=\"%s\"\n\tLine=\"%d\"\n\tProblem=\"%s\"",__FILE__,__FUNCTION__,__LINE__,errormessage); throw std::runtime_error(_errormessage);}

int main()
{
    bool fakecheck = false;
    if(!fakecheck)
        MYERROR("fake check is false!");

    return 0;
}

include <iostream>
#include <cstring>
#include <stdexcept>
using namespace std;

//چون حال ندارم هر بار تایپش کنم یه اسم مستعار براش میسازم
typedef unsigned int uint;

class MyString
{
public:
    //سازنده ی بدون آرگومان
    MyString()
    {
        // دیتا هیچوقت نباید خالی باشه چون ما تمام حزف های کلاس رو بدون شرط انجام میشه
        data = new char[1];
        // همیشه آخرین حرف باید پوچ باشه
        data[0]='\0';
    }
    //سازنده ی با آرگومان
    MyString(const char* in )
    {
        //اشاره گر رو آماده میکنیم
        data = new char[strlen(in)+1];
        //کپی میکنیم
        strcpy(data,in);
        // حرف آخرش رو هم پوچ میکنیم
        data[strlen(in)]='\0';
    }
    //سازنده ی کپی
    MyString(const MyString& other)
    {
        data = new char[strlen(other.data)+1];
        strcpy(data,other.data);
        data[strlen(other.data)]='\0';
    }
    //مخرب
    virtual ~MyString()
    {
        delete[] data;
    }
    //موقع سرچ معادل پیدا نشدن هست
    static const uint NullPosition = -1;
    //دیتا رو بر میگردونه
    const char* getdata()const
    {
        return data;
    }
    //اندازه رشته رو برمیگردونه
    uint getsize()const
    {
        return strlen(data);
    }
    // پاک میکنه
    void clear()
    {
        delete[] data;
        //حتما باید دیتا حداقل یه خونه داشته باشه تا ارور نده
        data=new char[1];
        data[0]='\0';
    }
    // یه تیکه از رشته رو بر میگردونه با استفاده از نقطه شروع و پایانش
    MyString substring(uint _start,uint _end=-1)const
    {
        //اگه پایانش منفی یک بود یعنی پایان رشته البته مقدار منطقیش منفی یک نیست
        uint __end = (_end!=-1)?_end:strlen(data)+1;
        if(_start>__end)//اگه نقطه شروع از پایان بزرگتر بود ارور بده
            throw std::runtime_error("MyString::substr : start point is greater than end point");
        MyString out;
        delete out.data;
        out.data= new char[__end-_start];//مقدار جدید خروجی
        for(int i=_start;i<__end;i++)// کپی کردن
            out.data[i-_start]=data[i];
        out.data[__end-_start]='\0';
        return out;
    }
    // یه رشته رو از داخل خود رشته پیدا میکنه و میتونین مشخص کنین از کجا شروع بشه
    uint findstring(const char* in,uint from=0)const
    {
        uint pos = (uint)strstr(data,in);
        if(pos==0)
            return -1;
        while(pos - (uint )data<from)
        {
            pos=(uint)strstr(&data[pos - (uint )data+1],in);
            if(pos==0)
                break;
        }
        if(pos - (uint )data<from  || pos - (uint )data>getsize())
            return -1;
        return pos - (uint )data;
    }
    // پیدا کردن با استفاده از نوع خود کلاس
    uint findstring(const MyString& in,uint from=0)const
    {
        return findstring(in.data,from);
    }
    // پاک کردن یه قسمت از رشته با استفاده از نقطه شروع و پایان
    void erase(uint start,uint end=-1)
    {
        //اگه منفی یک بود یعنی انتهاش
        uint _end=(end!=-1)?end:strlen(data);
        if(start>getsize()||_end>getsize())
            throw std::runtime_error("MyString::erase : start point or end point is greater than data size");
        //سایز رشته قبل از تغییر
        uint strsize=getsize();
        //کپی کردن کاراکتر های بعد از قسمتی که باید پاک بشه
        for(uint i=start;i<strsize;i++)
        {
            //یعنی توانایی کپی رو داره
            if(i+(_end-start)<strsize)
            {
                // رشته جلویی رو میاره میذاره جایی که باید پاک شه
                data[i]=data[i+(_end-start)];
                //پوچ میشه تا باقی نمونه
                data[i+(_end-start)]='\0';
            }
            else
                // قابل کپی نیست و باید پوچ شه
                data[i]='\0';
        }

//یادتون نره میتونین مموری رو فلاش کنین اما من اینکار رو نکردم
    }
    // وارد کردن یه رشته به داخل رشتمون  (پوستم سر دیباگ کردنش کنده شد)
    void insert(uint point,const char* in)
    {
        // اگه نقطه شروع بود کار رو سریع انجام میدم که جمع کردنش باشه
        if(point == 0)
        {
            MyString _a(in);
            //توضیحات جمع کردن رو بخونید
            *this = _a+*this;
            return;
        }
        //سایز قبل تغییر
        uint _s=getsize();
        // سایز ورودی برای اینکه لازم نباشه هر بار چک کنیم
        uint _inlen = strlen(in);
        //نگه میداریم تا حافظه جدید بسازیم
        char* buf = data;
        data = new char[_s+_inlen+1];
        //حافظه قدیمی رو کپی میکنیم
        memcpy(data,buf,sizeof(*buf)*strlen(buf));
        // حافظه قدیمی رو از بین میبریم
        delete[] buf;
        //کپی کردن
        for(uint i=_s;i>=point;i--)
        {
            // از محل جایی که باید پاک بشه حروف ها رو به اندازه سایزشون جلو میبریم
            data[i+_inlen]=data[i];
        }
        data[_s+_inlen]='\0';
        //اون رشته ای که باید وارد میکردیم رو  وارد میکنیم
        memcpy(&data[point],in,sizeof(*in)*_inlen);

    }
    //این همون بالایی هس با فرض اینکه نوعش ورودی از نوع خودشه
    void insert(uint point,const MyString& in)
    {
        insert(point,in.data);
    }
    // جایگزین کردن یه رشته با استفاده از نقطه شروعش
    void replace(uint start,const char* b)
    {
        // اگه اندازش بیشتر بود باید حافظه جدید حاضر کنیم
        if(start+strlen(b)>getsize())
        {
            // محل قدیمی رو نگه میداریم
            char* buf=data;
            //محل جدید رو حاضر میکنیم
            data= new char[start+strlen(b)+1];
            // محتوای قدیمی رو به جای جدید کپی میکنیم
            memcpy(data,buf,sizeof(*buf)*strlen(buf));
            data[start+strlen(b)]='\0';
            // حافظه قدیمی رو پاک میکنیم
            delete[] buf;
        }
        //اندازه ورودی رو بدست میاریم
        uint blen = strlen(b);
        // کپی میکنیم
        for(uint i=start;i<blen+start;i++)
            data[i]=b[i-start];
    }
    // این رو که دیگه معلومه
    void replace(uint start,const MyString& b)
    {
        replace(start,b.data);
    }
    // تمام کلمات آرگومان اول رو با آرگومان دوم جایگزین میکنه . نقطه شروع هم میتونین بهش بدین نظقطه پایان هم همینطور
    void replaceall(const char* what,const char* with,uint from=0,uint end=-1)
    {
        uint _d=findstring(what,from);
        while(1)
        {
            if(end<_d||_d==-1)
                break;
            erase(_d,_d+strlen(what));
            insert(_d,with);
            _d=findstring(what,_d+strlen(with));
        }
    }
    //معلومه دیگه
    void replaceall(const MyString& what,const MyString& with,uint from=0,uint end=-1)
    {
        replaceall(what.getdata(),with.getdata(),from,end);
    }


    //جمع کردن یه رشته با یه رشته دیگه
    MyString operator+(const char* in)const
    {
        MyString out;
        delete out.data;
        // مقدار جدید براش آماده میکنیم
        out.data = new char[strlen(in)+strlen(data)+1];
        // مقدار خود رشته رو کپی میکنیم
        memcpy(out.data,data,sizeof(*data)*strlen(data));
        // مقدار رشته دوم رو هم کپی میکنیم
        memcpy(&out.data[strlen(data)],in,sizeof(*in)*strlen(in));

out.data[strlen(in)+strlen(data)]='\0';
       

return out;
    }
 

  MyS

ring operator+(const MyString& in)const
    {
 

return *this + in.data;
    }
 

  //ک

ی کردن
    MyS

ring& operator = (const char* in)
    {
 

delete[] data;
       

//آماده کردن فضای جدید
       

data = new char[strlen(in)+1];
       

//کپی کردن
       

strcpy(data,in);
       

data[strlen(in)]='\0';
       

return *this;
    }
 

  MyS

ring& operator = (const MyString& in)
    {
 

*this = in.data;
       

return *this;
    }
 

  //ا

افه کردن به خود رشته
    MyS

ring& operator +=(const char* in)
    {
 

*this = *this + in;
       

return *this;
    }
 

  MyS

ring& operator +=(const MyString& in)
    {
 

*this+=in.data;
       

return *this;
    }
 

  // 

ررسی برابر بودن
    boo

 operator == (const MyString& other)const
    {
 

return !strcmp(other.data,data);
    }
 

  // 

ررسی برابر نبودن
    boo

 operator!= (const MyString& other)const
    {
 

return !(*this==other);
    }
 

  boo

 operator == (const char* other)const
    {
 

return !strcmp(other,data);
    }
 

  boo

 operator!= (const char* other)const
    {
 

return !(*this==other);
    }
 

  //د

ترسی به تک تک کاراکتر ها
    cha

& operator [] (uint in)
    {
 

if(in>strlen(data))//ارور بده اگه عدده زیاد بود
       

    throw std::runtime_error("MyString::operator [] : in is greater than data size");
       

return data[in];
    }
 

  con

t char& operator [] (uint in)const
    {
 

if(in>strlen(data))
       

    throw std::runtime_error("MyString::operator [] : in is greater than data size");
       

return data[in];
    }
p

ivate

    cha

* data;
};

یه 

ثا

()
{
    MyString a = "Hello World!";
    cout<<a.getdata()<<endl;

    return 0;
}

امیدوا