class和struct的区别就是class需要指明private 和 public 而 struct不需要
/*
类定义
*/
#include <iostream>
using namespace std;
struct Student {
public:
void eat(const string& food) {
cout << "我在吃" << food << endl;
}
void sleep(const int hour) {
cout << "我睡了" << hour << "小时" << endl;
}
void study(const string& course) {
cout << "我学习" << course << endl;
}
void who(void) {
cout << "我是" << m_name << ",今年" << m_age << "岁,编号" << m_no << endl;
}
void set_name(const string& name) {
m_name = name;
}
void set_age(const int age) {
m_age = age;
}
void set_no(const int no) {
m_no = no;
}
private:
string m_name;
int m_age;
int m_no;
};
int main(void) {
Student s;
s.set_name("小明");
s.set_age(12);
s.set_no(10001);
s.eat("饺子");
s.sleep(12);
s.study("语文");
s.who();
}
建立初始化的构造函数,用于在初始化的时候,对类进行构造
#include <iostream>
using namespace std;
class Student{
public:
Student(const string& name, int age, int no)
{
cout << "构造函数" << endl; //进行直接的构造
m_name = name;
m_age = age;
m_no = no;
}
void who(void) {
cout << "我叫" << m_name << ",今年" << m_age << "岁, 学号是" << m_no << endl;
}
private:
string m_name;
int m_age;
int m_no;
};
int main(void) {
//创建对象/实例化对象
//(...)指定构造函数需要的实参
Student s("张飞", 28, 10011);
s.who();
//构造函数不能显示调用
s.Student("张三, 29, 10012");
return 0;
}
使用time包构造函数,使用run进行代码的运行
#include <iostream>
#include <ctime>
#include <unistd.h>
#include <cstdio>
using namespace std;
/*
struct tm {
int time_hour;
int tm_min;
int tm_sec;
};
*/
class Clock{
public:
Clock(time_t t){
tm* local = localtime(&t);
hour = local->tm_hour;
minute = local->tm_min;
sec = local->tm_sec;
}
void run(void) {
while (1) {
printf("1");
sec = sec + 1;
if (sec == 60) {
sec = 0;
minute += 1;
if (minute == 60) {
minute = 0;
hour += 1;
if (hour == 24) {
hour = 0;
}
}
}
printf("\r\n%02d:%02d:%02d", hour, minute, sec);
fflush(stdout);
sleep(1);
}
}
private:
int sec, minute, hour;
};
int main() {
Clock c(time(NULL));
c.run();
return 0;
}
在数组中构造多个类,使用new构造动态的类数组
/*
多个对象数组
*/
#include <iostream>
using namespace std;
class Student {
public:
Student(const string& name, int age, int no):m_name(name), m_age(age), m_no(no){}
void who(void) {
cout << "我是" << m_name << ",年龄" << m_age << ",编号" << m_no << endl;
}
private:
string m_name;
int m_age;
int m_no;
};
int main(void) {
Student s = Student("小清", 10, 10002);
//构造出对象数组
Student arr[3] = {
Student("张飞", 12, 10001),
Student("小明", 30, 200001),
Student("小红", 20, 100001),
};
arr[0].who();
arr[1].who();
arr[2].who();
Student *p_s = new Student("小白", 13, 10001);
p_s->who();
delete p_s;
p_s = NULL;
Student* p_arry = new Student[2] {
Student("小明", 10, 10001),
Student("小花", 20, 10001)
};
p_arry[0].who();
p_arry[1].who();
delete[] p_arry;
p_arry = NULL;
}
在类里面定义新的类类型
#include <iostream>
using namespace std;
class A{
public:
/*
A(void){
cout << "A的无参构造函数" << endl;
m_i = 0;
}
*/
A(int i){
cout << "A的有参构造函数" << endl;
m_i = i;
}
int m_i;
};
class B{
public:
int m_j; //基本类型成员变量
A m_a = A(2); //成员子对象 进行无类型声明
};
int main(void)
{
B b;
cout << "基本类型" << b.m_j << endl;
cout << "类类型" << b.m_a.m_i << endl;
return 0;
}
两种条件定义下的构造函数, 即使用有参和无参的方式
#include <iostream>
using namespace std;
class Integer{
public:
Integer(void) {
cout << "Interger(void)" << endl;
m_i = 0;
}
//进行显示转换
/*explicit*/ Integer(int i) {
cout << "Integer(int)" << endl;
m_i = i;
}
void print(void) {
cout << m_i << endl;
}
private:
int m_i;
};
int main(void) {
Integer i;
i.print();
//1)先将100转换为Interger对象
//2)再使用转换结果(临时结果)对i进行赋值操作
//i = 100; //类型转换构造函数
// i.print();
//上面隐士转换代码可读性叉,推介显示转换
// i = (Integer)200;
i = Integer(200); //C++风格 对象的实例化
i.print();
return 0;
}
重新构造拷贝函数
#include <iostream>
using namespace std;
class A{
public:
A(int data = 0) {
cout << "A(int = 0)" << endl;
m_data = data;
}
/*
A(const A& that){
cout << "A(const A&)" << endl;
m_data = that.m_data;
}
*/
void print(void) {
cout << m_data << endl;
}
int m_data;
};
int main(void){
A a1(100);
// A a2(a1); //拷贝构造
// A a2 = A(a1);
A a2 = a1; //和上面写法等价
a1.print();
a2.print();
return 0;
}
类类函数的函数构造, 通过定义获取
#include <iostream>
using namespace std;
class A{
public:
A(int data = 0) {
cout << "A(int = 0)" << endl;
m_data = data;
}
A(const A& that){
cout << "A(const A&)" << endl;
m_data = that.m_data;
}
int m_data;
};
class B{
public:
A m_a; //成员子对象
};
int main(void){
B b1; //无参
B b2 = b1; //拷贝构造
cout << b1.m_a.m_data << endl; //0
cout << b2.m_a.m_data << endl; //0
return 0;
}
根据类进行拷贝赋值操作
#include <iostream>
using namespace std;
class A{
public:
A(void) {
cout << "A的无参构造" << endl;
}
A(const A& that) {
cout << "A的拷贝构造" << endl;
}
};
void foo(A a){}
A bar(void) {
A a; //无参
cout << "&a:" << &a << endl;
return a; //A tmp = a //拷贝
}
int main(void)
{
A a1; //无参
A a2 = a1; //拷贝
foo(a1); //拷贝
A a3 = bar(); //拷贝
cout << "&a3:" << &a3 << endl;
return 0;
}
对有参类进行直接的初始化操作
#include <iostream>
using namespace std;
class A{
public:
A(void) {
cout << "A的无参构造" << endl;
}
A(const A& that) {
cout << "A的拷贝构造" << endl;
}
};
void foo(A a){}
A bar(void) {
A a; //无参
cout << "&a:" << &a << endl;
return a; //A tmp = a //拷贝
}
int main(void)
{
A a1; //无参
A a2 = a1; //拷贝
foo(a1); //拷贝
A a3 = bar(); //拷贝
cout << "&a3:" << &a3 << endl;
return 0;
}
构造类类函数,进行类函数的定义
#include <iostream>
using namespace std;
class A{
public:
A(int i){
cout << "A(int)" << endl;
m_i = i;
}
int m_i;
};
class B{
public:
B(void):m_a(123){ //可以先开始进行构造
cout << "B(void)" << endl;
}
A m_a; //成员子对象
}
int main(void)
{
B b;
cout << b.m_a.m_i << endl;
return 0;
}
使用全局变量来初始化类
/*
使用全局变量构造函数
*/
#include <iostream>
using namespace std;
int num = 100;
class A {
public:
A(void):m_c(200), m_r(num){
}
int& m_r;
const int m_c;
};
int main() {
A a;
cout << a.m_r << endl;
}
对输入的参数,如果是NULL, 使用str?str:"" 构造三目运算
/*
构造类函数用于定义
*/
#include <iostream>
#include <cstring>
using namespace std;
class Dummy {
public:
//将NULL进行形式转换,转换成""
Dummy(const char* str):m_str(str?str:""), m_len(strlen(str?str:""))
{}
int m_len;
string m_str;
};
int main() {
Dummy d(NULL);
cout << d.m_str << d.m_len << endl;
return 0;
}
原文链接: https://www.cnblogs.com/hyq-lst/p/12603735.html
欢迎关注
微信关注下方公众号,第一时间获取干货硬货;公众号内回复【pdf】免费获取数百本计算机经典书籍
原创文章受到原创版权保护。转载请注明出处:https://www.ccppcoding.com/archives/195079
非原创文章文中已经注明原地址,如有侵权,联系删除
关注公众号【高性能架构探索】,第一时间获取最新文章
转载文章受原作者版权保护。转载请注明原作者出处!