城市生活网官方网站app,小程序制作第三方平台,切削工具东莞网站建设,cms系统做漫画网站C有六个默认函数#xff0c;分别是#xff1a; 1、默认构造函数; 2、默认拷贝构造函数;
3、默认析构函数; 4、赋值运算符; 5、取址运算符;
6、取址运算符const; 构造函数
构造函数(初始化类成员变量)#xff1a; 1、属于类的成员函数之一 … C有六个默认函数分别是 1、默认构造函数; 2、默认拷贝构造函数;
3、默认析构函数; 4、赋值运算符; 5、取址运算符;
6、取址运算符const; 构造函数
构造函数(初始化类成员变量) 1、属于类的成员函数之一 2、构造函数没有返回类型 3、构造函数的函数名必须与类名相同 4、构造函数不允许手动调用(不能通过类对象调用) 5、构造函数在类对象创建时会被自动调用 6、如果没有显示声明构造函数系统会生成一个默认的构造函数 7、如果显示声明了构造函数那么默认构造函数将不会在被创建 8、构造函数不被设置为静态成员函数 9、构造函数的函数首部之前或函数首部之后不能用const修饰 10、new一个类指针也会触发构造函数的调用 malloc不会 11、构造函数通过函数重载的方式也可以拥有多个 12、构造函数也可以使用形参默认值 13、构造函数可以是private的
#include string.h
#include stdlib.h
#include iostream
using namespace std;#if 0 // 构造函数class Node
{public://Node();Node(int n 0, char* ptr NULL, float score 1.3f);// static Node(); // error// Node() const; // error// const Node(); // errorprivate:int m_num;char* m_ptr;float m_fscore;
};// 类成员变量初始化方式2常用这种方式
// 通常普通类成员变量都需要在构造函数上进行初始化。
//Node::Node()
// : m_num(111),
// m_ptr(NULL),
// m_fscore(0.0)
//{
// // 类成员变量初始化方式1
// //m_num 10;
//
// cout construct: m_num endl;
//}Node::Node(int n, char* ptr, float score): m_num(n),m_ptr(NULL),m_fscore(score)
{m_ptr new char[100];strcpy(m_ptr, ptr);cout m_num : m_ptr : m_fscore endl;
}int main(int argc,char *argv[])
{// 触发构造函数调用Node n;// n.Node(); // errorNode n1(1, st, 1.1);// 触发构造函数调用//Node* n1 new Node;// 不会触发构造函数调用//Node* n2 (Node*)malloc(sizeof(Node));return 0;
}
#endif
形参默认值
形参默认值 1、给函数的形参一个默认的值。 2、如果我们在调用函数时指定实参的值则形参的默认值不生效。 3、如果调用函数时没有给实参值形参默认值才会生效。 4、形参默认值只需要在函数声明时写出来即可。 如果有函数声明的前提下, 在函数定义时写形参默认值会报错。 5、形参默认值只能出现在形参列表的最右边(后边)。
#if 0 // 形参默认值class Node
{public:// 形参默认值void fun(int x, int y, int num 12, int z 1);void display();private:int m_num;
};void Node::fun(int x, int y, int num, int z)
{m_num num;
}void Node::display()
{cout m_num endl;
}int main()
{Node n;n.fun(1, 2, 12345);n.display();n.fun(1, 2);n.display();return 0;
}#endif
函数重载
函数重载 1、在C允许出现同名函数 (1) 形参个数不同 (2) 形参类型不同 (3) 形参顺序不同 前提类型不同 (4) 函数的返回类型不影响 2、函数重载时调用函数是在编译期间就确定了具体调用对象 因为我们将函数重载称之为静态联编 3、重载函数调用时不要出现二义性问题
#if 0 // 函数重载
#include stdio.hvoid fun(int x, float y)
{cout fun(int x, float y) endl;
}void fun(int x, int y)
{cout void fun(int x, int y) endl;
}void fun(int x, int y, int z 0)
{cout void fun(int x, int y, int z 0) endl;
}void fun()
{cout fun() endl;
}void fun(float x, int y)
{cout fun(float x, int y) endl;
}int main()
{ fun(1.1f, 12);fun(12, 1.3f);fun(1, 2, 3);fun(1, 2); // error: 出现了二义性return 0;
}#endif单例模式
#if 1 // 设计模式单例模式class Node
{public:static Node* getInstance();private:Node();private:static Node* m_ptr;
};Node* Node::m_ptr NULL;Node::Node()
{cout construst endl;
}Node* Node::getInstance()
{if (m_ptr NULL){m_ptr new Node;}return m_ptr;
}int main()
{//Node n; // error: ‘Node::Node()’ is private//Node* n1 new Node; // error: ‘Node::Node()’ is private//Node* n2 (Node*)malloc(sizeof(Node)); // 可以Node* n Node::getInstance();cout n endl; Node* n1 Node::getInstance();cout n1 endl; Node* n2 Node::getInstance();cout n2 endl; Node* n3 Node::getInstance();cout n3 endl; Node* n4 Node::getInstance();cout n4 endl; return 0;
}
析构函数
析构函数 1、类对象或类指针销毁时析构函数会被自动调用 2、如果没有显示声明析构函数则系统会生成一个默认的析构函数 3、如果显示声明了析构函数则不会在生成默认的析构函数 4、析构函数没有返回类型没有形参列表且函数名与类名相同 5、析构函数只有一个不能重载 6、析构函数不能设置为私有的 7、析构函数可以手动调用但不允许 8、如果类对象的作用域相同那么在销毁时析构函数的执行顺序与构造相反。
#include iostream
using namespace std;class Node
{public:Node();Node(int n);~Node();//~Node(int num 0); // error: destructors may not have parametersvoid fun();inline void fun1(){cout fun1 endl;}private:int* m_ptr;
};Node::Node(): m_ptr(NULL)
{if (m_ptr NULL){m_ptr new int[100];}cout construct endl;
}Node::Node(int n): m_ptr(NULL)
{if (m_ptr NULL){m_ptr new int[100];}*m_ptr n;cout *m_ptr construct endl;
}void Node::fun()
{Node n(8);cout fun endl;
}Node::~Node()
{cout *m_ptr destruct endl;if (m_ptr ! NULL){delete[] m_ptr;m_ptr NULL;}
}int main(int argc,char *argv[])
{Node n0(0), n2(2);n0.fun();Node n3(3), n4(4), n5(5);//Node* n1 new Node;//delete n1;// n0.~Node(); // 可以但不允许cout aaa endl;return 0;
}
内联函数
内联函数 1、在普通类成员函数声明之前添加 inline 关键字 2、内联函数通常函数定义和函数声明都写在类声明中 3、内联函数的函数体中不能出现复杂结构 4、函数函数体中的代码一般3行左右 5、通常被频繁调用的函数才需要设置为内联函数 6、内联函数是进行函数逻辑的替换其不进行真正的函数调用减少系统开销 7、系统会自动判断当前函数是否是内联函数也会自动判别是否需要使用内联。
内联函数与c的宏函数有什么不同
1、宏函数是在编译阶段处理是纯字符串替换 内联函数是运行阶段处理是函数逻辑替换 2、宏函数无法调试 内 联函数可以调试
3、宏函数没有返回值; 内联函数有返回值
4、宏函数不能访问类成员 内联函数可以访问类成员
拷贝构造函数
拷贝构造函数 1、拷贝构造函数属于构造函数的重载 2、拷贝构造函数要求形参中有一个当前类的类对象的引用 3、如果没有显示声明拷贝构造函数系统会生成一个默认的拷贝构造函数 4、如果显示声明了拷贝构造函数那么默认拷贝构造函数将不会在被创建 5、当使用一个老对象去构造一个新对象时会调用拷贝构造函数 (1) 用一个老对象构造一个新对象,或者新对象赋给老对象。 (2) 当函数的形参是一个非引用的类对象时,实参到形参传递时。 (3) 函数返回一个非引用的类对象时。 6、如果没有显示声明和定义拷贝构造函数时类中的非指针类成员的值是可以被拷贝的。 默认拷贝构造函数负责执行了值的拷贝。 7、如果显示声明和定义拷贝构造函数后类中的所有成员变量都需要我们手动进行拷贝。 8、拷贝分为浅拷贝和深拷贝默认拷贝构造函数只能进行浅拷贝。 9、浅拷贝只进行值的拷贝深拷贝还会执行内存拷贝。 #include iostream
using namespace std;class Node
{public:Node();Node(const Node n);~Node();private:int m_num;int* m_ptr;
};Node::Node(): m_num(12),m_ptr(NULL)
{if (m_ptr NULL){m_ptr new int[100];}*m_ptr 123;cout construct m_num -- *m_ptr endl;
}Node::Node(const Node n): m_num(0)
{if (m_ptr NULL){m_ptr new int[100];}*m_ptr *(n.m_ptr);cout copy construct m_num -- *m_ptr endl;
}Node::~Node()
{cout destruct: m_num -- *m_ptr : m_ptr endl;if (m_ptr ! NULL){delete[] m_ptr;m_ptr NULL;}
}int main(int argc,char *argv[])
{Node n1;Node n2(n1);return 0;
} #include iostream
using namespace std;class Node
{public:Node();Node(const Node n);~Node();Node fun(Node n);private:int m_num;
};Node::Node(): m_num(12)
{cout construct: m_num endl;
}Node::Node(const Node n): m_num(0)
{cout copy construct: m_num endl;
}Node Node::fun(Node n)
{n.m_num 111;cout fun endl;return n;
}Node::~Node()
{cout destruct: m_num endl;
}int main(int argc,char *argv[])
{Node n1;//Node n2(n1);//Node n3 n1;//Node n3 n1.fun(n1);// 如果有返回但我们没有接收的时候系统会自动生成一个临时(隐藏)对象// 当前的临时(隐藏)对象的生存周期是从return开始当前函数调用语句执行完毕结束。n1.fun(n1);cout --------- endl;return 0;
}
