C++ 类成员函数

成员函数可以定义在类定义内部，或者单独使用范围解析运算符 :: 来定义。

需要强调一点，在 :: 运算符之前必须使用类名。调用成员函数是在对象上使用点运算符（.），这样它就能操作与该对象相关的数据

#include <iostream>

using namespace std;

class Box
{
public:
double length;         // 长度
double breadth;        // 宽度
double height;         // 高度

// 成员函数声明
double getVolume(void);
void setLength( double len );
void setBreadth( double bre );
void setHeight( double hei );
};

// 成员函数定义
double Box::getVolume(void)
{
return length * breadth * height;
}

C++ 类访问修饰符

C++定义一个类,如果成员变量没有说明是共有还是私有那默认的是哪一个？

struct默认共有，class默认私有，这是class和struct唯一的区别

公有成员在程序中类的外部是可访问的。您可以不使用任何成员函数来设置和获取公有变量的值。

私有成员变量或函数在类的外部是不可访问的，甚至是不可查看的。只有类和友元函数可以访问私有成员。

#include <iostream>

using namespace std;

class Box
{
public:
double length;
void setWidth( double wid );
double getWidth( void );

private:
double width;
};

// 成员函数定义
double Box::getWidth(void)
{
return width ;
}

void Box::setWidth( double wid )
{
width = wid;
}

 

保护成员变量或函数与私有成员十分相似，但有一点不同，保护成员在派生类（即子类）中是可访问的。

#include <iostream>
using namespace std;

class Box
{
protected:
double width;
};

class SmallBox:Box // SmallBox 是派生类
{
public:
void setSmallWidth( double wid );
double getSmallWidth( void );
};

// 子类的成员函数
double SmallBox::getSmallWidth(void)
{
return width ;
}

继承中的特点

有public, protected, private三种继承方式，它们相应地改变了基类成员的访问属性。

• 1.public 继承：基类 public 成员，protected 成员，private 成员的访问属性在派生类中分别变成：public, protected, private

• 2.protected 继承：基类 public 成员，protected 成员，private 成员的访问属性在派生类中分别变成：protected, protected, private

• 3.private 继承：基类 public 成员，protected 成员，private 成员的访问属性在派生类中分别变成：private, private, private

但无论哪种继承方式，上面两点都没有改变：

• 1.private 成员只能被本类成员（类内）和友元访问，不能被派生类访问；

• 2.protected 成员可以被派生类访问。

C++ 友元函数

 

友元函数跟成员函数有相同的权限，都可以访问公有、保护、私有的成员。
在C++中，如果想让类中的成员数据可以被其他函数访问，可以通过友元函数声明，来共享类中的资源。友元类函数对类的属性和方法的访问能力等同于类的成员函数。

友元可以是一个函数，该函数被称为友元函数；友元也可以是一个类，该类被称为友元类，在这种情况下，整个类及其所有成员都是友元。

#include <iostream>

using namespace std;

class Box
{
double width;
public:
friend void printWidth( Box box );
void setWidth( double wid );
};

// 成员函数定义
void Box::setWidth( double wid )
{
width = wid;
}

// 请注意：printWidth() 不是任何类的成员函数
void printWidth( Box box )
{
/* 因为 printWidth() 是 Box 的友元，它可以直接访问该类的任何成员 */
cout << "Width of box : " << box.width <<endl;
}

C++ 类构造函数 & 析构函数

类的构造函数是类的一种特殊的成员函数，它会在每次创建类的新对象时执行。

构造函数的名称与类的名称是完全相同的，并且不会返回任何类型，也不会返回 void。构造函数可用于为某些成员变量设置初始值。

使用初始化列表来初始化字段

使用初始化列表来初始化字段：

Line::Line( double len): length(len)
{
cout << "Object is being created, length = " << len << endl;
}

 

上面的语法等同于如下语法：

Line::Line( double len)
{
cout << "Object is being created, length = " << len << endl;
length = len;
}

 

初始化列表以冒号开头，后跟一系列以逗号分隔的初始化字段。

为什么使用初始化列表

初始化类的成员有两种方式，一是使用初始化列表，二是在构造函数体内进行赋值操作。使用初始化列表主要是基于性能问题，对于内置类型，如int, float等，使用初始化类表和在构造函数体内初始化差别不是很大，但是对于类类型来说，最好使用初始化列表，为什么呢？由上面的测试可知，使用初始化列表少了一次调用默认构造函数的过程，这对于数据密集型的类来说，是非常高效的

成员变量的初始化顺序

成员是按照他们在类中出现的顺序进行初始化的，而不是按照他们在初始化列表出现的顺序初始化的，看代码。

struct foo
{
int i ;
int j ;
foo(int x):i(x), j(i){}; // ok, 先初始化i，后初始化j
};

再看下面的代码

struct foo
{
int i ;
int j ;
foo(int x):j(x), i(j){} // i值未定义
};

这里i的值是未定义的，虽然j在初始化列表里面出现在i前面，但是i先于j定义，所以先初始化i，但i由j初始化，此时j尚未初始化，所以导致i的值未定义。所以，一个好的习惯是，按照成员定义的顺序进行初始化。

类的析构函数

类的析构函数是类的一种特殊的成员函数，它会在每次删除所创建的对象时执行。

析构函数的名称与类的名称是完全相同的，只是在前面加了个波浪号（~）作为前缀，它不会返回任何值，也不能带有任何参数。析构函数有助于在跳出程序（比如关闭文件、释放内存等）前释放资源。

#include <iostream>

using namespace std;

class Line
{
public:
void setLength( double len );
double getLength( void );
Line();   // 这是构造函数声明
~Line();  // 这是析构函数声明

private:
double length;
};

// 成员函数定义，包括构造函数
Line::Line(void)
{
cout << "Object is being created" << endl;
}
Line::~Line(void)
{
cout << "Object is being deleted" << endl;
}

void Line::setLength( double len )
{
length = len;
}

double Line::getLength( void )
{
return length;
}
// 程序的主函数
int main( )
{
Line line;

// 设置长度
line.setLength(6.0);
cout << "Length of line : " << line.getLength() <<endl;

return 0;
}
当上面的代码被编译和执行时，它会产生下列结果：
Object is being created
Length of line : 6
Object is being deleted

C++ 拷贝构造函数

拷贝构造函数是一种特殊的构造函数，它在创建对象时，是使用同一类中之前创建的对象来初始化新创建的对象。拷贝构造函数通常用于：

• 通过使用另一个同类型的对象来初始化新创建的对象。

• 复制对象把它作为参数传递给函数。

• 复制对象，并从函数返回这个对象。

如果在类中没有定义拷贝构造函数，编译器会自行定义一个。如果类带有指针变量，并有动态内存分配，则它必须有一个拷贝构造函数。拷贝构造函数的最常见形式如下：

classname (const classname &obj) { // 构造函数的主体 }

在这里，obj 是一个对象引用，该对象是用于初始化另一个对象

#include <iostream>

using namespace std;

class Line
{
public:
int getLength( void );
Line( int len );             // 简单的构造函数
Line( const Line &obj);      // 拷贝构造函数
~Line();                     // 析构函数

private:
int *ptr;
};

// 成员函数定义，包括构造函数
Line::Line(int len)
{
cout << "调用构造函数" << endl;
// 为指针分配内存
ptr = new int;
*ptr = len;
}

Line::Line(const Line &obj)
{
cout << "调用拷贝构造函数并为指针 ptr 分配内存" << endl;
ptr = new int;
*ptr = *obj.ptr; // 拷贝值
}

Line::~Line(void)
{
cout << "释放内存" << endl;
delete ptr;
}
int Line::getLength( void )
{
return *ptr;
}

void display(Line obj)
{
cout << "line 大小 : " << obj.getLength() <<endl;
}

// 程序的主函数
int main( )
{
Line line(10);

display(line);

return 0;
}