C++笔记_03面向对象4

//面向对象4，定义控制台应用程序的入口点


#include<iostream>
#include<string.h>
using namespace std;




#include"public.h"


/*类和对象*/






/*
初始化与赋值的区别


(c++)区别说明：赋值操作是在两个已经存在的对象间进行的，而初始化是要创建一个新的对象，
并且其初值来源于另一个已存在的对象。编译器会区别这两种情况，赋值的时候调用重载
的赋值运算符，初始化的时候调用拷贝构造函数。如果类中没有拷贝构造函数，则编译器
会提供一个默认的。这个默认的拷贝构造函数只是简单地复制类中的每个成员。


(c)http://blog.csdn.net/mhjcumt/article/details/7351032




*/






/*


函数返回值规则
    。。。。C和C++区别里面
区别为 1.小于等于4个字节，，，，2.小于等于8个字节怎么返  C语言中
C++ 中，   返回对象， 返回内置类型


返回值不可以引用，因为，寄存器没有地址




函数return的值 通过寄存器带出来，寄存器不会取地址，
*1* 返回值小于等于4个字节
函数执行完毕后，如果返回值小于等于4字节，则会将值保存在寄存器eax中，然后再调用函数中通过读取eax的值来获取返回值
*2* 返回值大小在[5,8]字节范围内
因为eax寄存器只有4个字节，所以，当返回值在[5,8]字节范围内时，
一般采用eax和edx联合返回的方式进行的。期中eax存储返回值的低4字节，edx存储返回值的高4字节。
*3* 返回值大于8个字节是
主调函数在其栈中的局部变量区域中额外开辟一片空间，将其一部分作为传递返回值的临时对象temp。
将temp对象的地址作为隐藏参数传递给被调函数函数。
被调函数函数将数据拷贝给temp对象，并将temp对象的地址用eax传出。
被调函数返回后，主调函数将eax指向的temp对象的内容拷贝给n。 


http://m.blog.csdn.net/wanna_wsl/article/details/70550825


*/


/*
返回内置类型的时候，产生的都是寄存器的立即数（也就是常量值）

返回自定义类型的时候，也是通过寄存器返回的 <=8 字节，，
但是指向引用的时候，编译器会自动产生临时量


返回对象的时候，一律产生临时量，并把临时量的地址作为实参传递进来，
被调用函数通过访问ebp+8就能访问 调用方 临时内存的地址


内置类型   
char short int long float double
char *  shor *  int *  long * float * double *
//const右边有*的话，const绝对不能丢
char &  shor &  int &  long & float & double &

自定义类型
struct union enum class没有构造       非对象类型的自定义类型
<=4
[4 ,8]
>=8


*/


int Getint()
{
int value = 10;
return value;
}


int main()
{
int val = Getint();


//int *val2 = &Getint();//error
//int &ret = Getint();   //1 2 3 4 5


//int *const &p = Getint();  //error


/*
这样讲哈，，，  
函数return之后的值是放在eax寄存器里面的，
并且由于器存器不能取地址，所以，指针取地址是无效的，
再者，想要引用返回值的话，有个方法就 const (例子：const int &ret = Getint() )
加const 会产生临时量，这个临时量可以取地址，例子中ret取地址后将临时量的内容保存到它里面。嗯哼，至于为什么会产生临时量，后续百度
（这个临时量是产生在函数调用之后）
*/


//汇编上， 返回指针和引用是一样的






return 0;
}






#if 0
typedef struct _Data
{
int data;
}Data;


class Test
{
public:
Test(Data val):mvalue(val){}
Data Getvalue(){return mvalue;}
/**/
Data Getvalue()const  {return mvalue;}
private:
Data mvalue;
};




int GetInt()
{
int data = 10;
return data;
}


Data GetData()
{
Data data = {10};
return data;
}






int main()
{
Data d1={20};
Test t1(d1);


Data a1 = t1.Getvalue();
//int &b1 = t1.Getvalue();//err 寄存器不能取地址
Data &b1 = t1.Getvalue(); 
const Data &c1 = t1.Getvalue();//加入const 会产生临时量，位于main的堆栈中
/*对象 返回 对象的时候 都会产生临时量*/


//const Test t2(20);


//int a2 = t2.Getvalue();
//const int &b2 = t2.Getvalue();






return 0;
}
#endif 


















#if 0
/*
普通的成员方法    this
1.调用的时候必须依赖一个对象
2.能访问私有和保护的成员
3.类的作用域


static的成员方法   无this
1.调用的时候不用依赖对象，不是thiscall
2.能访问私有和保护的static成员??(但是，只能访问不依赖对象的成员)
3.类的作用域




常成员方法：this的指向被修饰成const   const this
1.调用的时候必须依赖一个对象 
2.能访问私有和保护的成员
3.类的作用域 
***常对象【只能】调用常方法，常方法不能调用普通成员方法，可以调用static成员方法
常方法只能访问成员，不能修改成员
，***


*/








class Counter
{
public:
Counter():_counter(0)//,_number(0)
{
_number++;
}
/*
const int *  -> int *        err
int * -> const int *         ok
consst int * -> const int *  ok
*/




//_thiscall
void show(/*Counter *const this  */)
{
cout<<"counter:"<<_counter<<endl;
}


void show(/*cosnt Counter *const this  */)const//会与上面的函数构成重载
{
cout<<"counter:"<<_counter<<endl;
}


//_cdecl
static void showNumber() //不含有this指针，不需要对象  
{
cout<<"number:"<<_number<<endl;
}
private:
int _counter;
static int _number;//位于数据段 .data
};
int Counter::_number = 0;//静态成员的初始化就与对象就没关系了






int main()
{
//Counter *p = new counter();
//p->show();
//delete p;


Counter c1;
Counter c2;
Counter c3;


Counter::showNumber();


const Counter c5;//&c5 const Counter* const this
c5.show();//Counter *const this


return 0;
}


#endif


#if 0
typedef enum
{
EN_LOGIN = 1,
EN_REGISTER,
EN_EXIT
}ENType;




typedef void (CMenu::*PFUNC)();




typedef struct _FuncMap
{
int choice;
PFUNC pfunc;
}FuncMap;
//table driver
FuncMap gFuncMap[]=
{
{EN_LOGIN, &CMenu::Login},
{EN_REGISTER, &CMenu::Register},
{EN_EXIT, &CMenu::Exit}
};




void CMenu::Run()
{
int choice = 0;
int size = sizeof(gFuncMap)/sizeof(gFuncMap[0]);
while(_bRunning)
{
ShowLoginMenu();
cin>>choice;
getchar();


for(int i=0;i<size;++i)
{
if(choice == gFuncMap[i].choice)
{
(this->*gFuncMap[i].pfunc)();//通过函数指针调用函数，编译器不知道你调用的是哪个对象
}
}


}


}


void CMenu::Login()
{
cout<<"username:";
gets(_name);
cout<<"password:";
gets(_pwd);


if(_userDB.checkUser(_name,_pwd))
{
//登录成功
}
else
cout<<"login error!"<<endl;
}


void CMenu::Register()
{
cout<<"username:";
gets(_name);
cout<<"password:";
gets(_pwd);


if(_userDB.Query(_name))
{
_userDB.Register(_name,_pwd);
}
else
cout<<"name invalid!"<<endl;
}


void CMenu::Exit()
{
exit(0);
}




int main()
{
CMenu menu;
menu.Run();


return 0;
}
#endif


#if 0
class Node
{
public:
Node(int data = 0):madata(data),mpnext(NULL){}
private:
int madata;
Node *mpnext;


//友元类，，声明为友元类，友元类中的所有成员方法都可以访问该类中的私有以及公有成员变量
//友元的关系不能传递，，是单一的   CLink是Node的友元， CLink可以访问Node的成员，但是Node不能访问CLink的成员
//A和B是友元，B和C是友元，，，不能说A和C是友元，，，
friend class CLink;
};




class CLink
{
public:
CLink()
{
mphead = new Node;//会调用Node的构造函数
}
~CLink()
{
Node *pcur = mphead;
while(pcur != NULL)
{
mphead = mphead->mpnext;
delete mphead;
pcur = mphead;
}
}


void insertHead(int val)
{
Node *ptmp = new Node(val);
ptmp->mpnext = mphead->mpnext;
mphead->mpnext = ptmp;
}


void insertTail(int val)
{
Node *ptmp = new Node(val);
Node *pcur = mphead;
while(pcur->mpnext != NULL)
{
pcur = pcur->mpnext;
}
pcur->mpnext = ptmp;
}


void show()
{
Node *pcur = mphead->mpnext;
while(pcur != NULL)
{
cout<<pcur->madata<<" ";
}
cout<<endl;
}


private:
Node *mphead;


};








int main()
{
CLink link;




return 0;
}


#endif