侯捷C++学习（一）

//c++学习
//标准库非常重要
//要规范自己的代码
complex c1(2,1);
complex c2;
complex* pc = new complex(0,1);
string s1("Hello");
string s2("world");
string* ps

#include<iostream>
using namespace std;
int main() {
int i=7;
cout<<"i="<<i<<endl;
return 0;
}
#include<iostream>
#include"complex.h"//防卫式声明
using namespace std;
int main() {
complex c1(2.1);
complex c2;
cout<<c1<<endl;
cout<<c2<<endl;
c2=c1+5;
c2=7+c1;
c2=c1+c2;
c2 +=3;
c2= -c1;
cout<<(c1=c2)<<endl;
cout<<(c1!=c2)<<endl;
cout<<conj(c1)<<endl;
return 0;
}
class complex {
public:
complex (double r=0,double i=0)
: re (r),im (i);//构造函数才有的初值列，
// { }
complex& operator +=(const complex&);
double real () const {
return re;
}
double imag () const {
return im;
}
private:
double re ,im;
friend complex&_doapl (complex*,const complex&);
}
{
complex c1(2,1);
complex c2;
complex* p = new complex(4);
//构造函数是没有返回值的
}
//构造函数可以有很多个overloading重载同名可以存在重载
//常常发生在构造函数里
class complex {
public:
complex (double r=0,double i=0)//
:re(r),im(i) {
}
complex () :re(0),im(0);
{}//不允许重载
complex& operator += (const complex&);
double real () const {
return re;
}
double imag () const {
return im;
}
private:
double re,im;
friend complex&_doapl (complex*,const complex&);
};
void real(double r) const {
re =r;
}
//构造函数在private区域
//表示这个函数是不可以被外界调用的
class complex {
public:
complex (double r = 0,double i = 0)
:re(r),im(i) {
}
complex& operator +=(const complex&);
double real () const {
return re;
}
double imag () const {
return im;
}
private:
double re,im;
friend complex&_doapl (complex*,const complex&);
};
{
complex c1(2,1);
complex c2;
...
}
//Singleton单份
//可以把构造函数写在private里面
//**在函数的后面加const class分类里对于不改变数据的，在函数的后面加const
//比如把函数拿出来的
//对于上面的代码
{
complex c1(2,1);
cout<<c1.real();
cout<<c1.imag();
}

{
const complex c1(2,1);
cout<< c1.real();
cout<< c1.imag();
}
//要有const的话要都有const.周全的代码正规
//参数传递
class complex {
public:
complex (double r= 0, double i = 0)
:re (r) , im(i) {
}
complex operator += (const complex&);
double real () const {
return re;
}
double imag () const {
return im;
}
private:
double re,im;

friend complex&_dopal (complex*,const complex&);
};
ostrean&
operator<< (ostream& os, const complex& x) {
return os<< '(' <<real (x) <<','
<< imag (x) <<'(';
}
//尽量不要 pass by value 引用就是一个指针
//传递引用防止更改所以我们要pass by reference (to const)
//返回值的传递尽量by reference（to const)
calss complex {
public:
complex (double r = 0,double i = 0)
:re (r), im (i);
{ }
complex& operator += (const complex&);
double real () const {return re;}
double imag () const {return im;}
private:
double re,im;
friend complex&_dopal (complex*, const complex);
};
ostream&
operator << (ostream& os, const complex& x) {
return os << '(' <<real (x) << '.'
<< imag (x) << ')';
}
//尽量使用reference
class complex {
public:
complex (double r = 0,double i = 0)
:re(r),im(i);
{ }
complex& operator += (const complex&);
double real () const {
return re;
}
double imag () const {
return im;
}
private:
double re,im;
friend complex&_doapl (complex*, const complex);
};
inline complex&
_doapl (complex*,const complex& r) {
this->re += r.re;
this->im += r.im;
return *this;
}
//friend(友元）因为我们是朋友所以可以直接取得private里面的re im
//private不让外界取得re im
class complex {
public:
complex (double r = 0,double i = 0)
:re(r),im(i) {
}
int func(const complex& param) {
return param.re + param.im;
}
private:
double re,im;
};
{
complex c1(2,1);
complex c2;

c2.func(c1);
}
//相同的class的各个objects互为friends(友元）
//class body 外的各种定义
//do assignment plus
inline complex&
_doapl(complex* ths, const complex& r) {
ths->re += r.re;//第一参数将会被改动
ths->im += r.im;//第二参数将不会被改动
return *ths;
}
inline complex&
complex::operator += (const complex& r) {
return _doapl (this, s);
}
///什么情况下不可以使用by reference
//c1+c2的时候+完的数值会被改变

//操作符重载—1，成员函数
//所有的成员函数都会带有一个隐藏的参数 this
//不可以在参数列写出来
inline complex&
_doapl(complex* ths,const complex& r) {
ths->re += r.re;
ths->im += r.im;
return *ths;
}
inline complex&
complex::operator +=(const complex& r) {
return _doapl (this,r);
}
{
complex c1(2,1);
complex c2(5);
c2 +=c1;
//??c3 += c2 += c1;
//要考虑到操作符重载，在设计函数的时候要考虑到问号里连续使用的状况
//连串使用的时候

}
//global函数
//class body之外的各种定义
inline double
imag(const complex& x) {
return x.imag ();
}
inline double
real(const complex& x) {
return x.real ();
}
{
complex c1(2,1);
cout << imag(c1);
cout << real(c1);
}
//operator overloading(操作符重载-2，非成员函数
inline complex
operator + (const complex& x, const complex& y) {
return complex (real (x) + real (y),
imag (x) + imag (y));
}
inline complex
operator + (const complex& x,double y) {
return complex (real (x) + y,imag (x));
}
inline complex
operator + (double x,const complex& y) {
return complex (x + real (y), imag (y));
}
--------->>>>> {
complex c1(2,1);
complex c2;
c2 = c1 + c2;
c2 = c1 + 5;
c2 = 7 + c1;
}
//上面的这些函数绝对不可以使用return by reference,
//因为，它们返回的必定是个local object
//也就是说加过的东西没有放的地方，(x + real (y), imag (y))
//typename();
//生命短暂 temp object 临时对象 return complex ();
//构造函数是有默认值的0
------------->>>>>>
inline complex
operator + (const complex& x)
{
return x;
}
inline complex
operator - (const complex& x)
{
return complex (-real (x), -imag (x););
}
{
complex c1 (2,1);
complex c2;
cout << -c1;
cout << +c1;
}
//正号和负号，只有一个参数的前面有+-号
// return complex (-real (x), -imag (x););
//临时对象
//上面的那句是正号没有变化，标准库里的，可以把它reference
--------->>>>>
inline bool
operator == (const complex& x,
const complex& y)
{
return real (x) == real (y)
&& imag (x) == imag (y);
}
inline bool
operator == ( const complex& x,double y)
{
return real (x) == y && imag (x) ==0
}
inline bool
operator == (double x, const complex& y)
{
return x == real (y) &&&imag (y) ==0;
}
{
complex c1(2,1);
complex c2;
cout << (c1 ==c2);
cout << (c1 == 2);
cout << (0 == c2);
}
----------->>
inline complex
conj (const complex& x)
{
return complex (real (x),-imag (x));
}
#include<iostream.h>
ostream&
operator << (ostream& os,const complex& x)
{
return os << '(' << real (x) << ','
<< imag (x) << ')';
}
{
complex c1(2,1);
cout << conj(c1);
cout << c1 << conj(c1);
}
//共轭复数