网站制作需要学习什么,网站建设与域名备案,怎样优化网络速度,宿州高端网站建设概述
对象#xff1a;真实存在的事物
类#xff1a; 多个对象抽取其共同点形成的概念 静态特征提取出的概念称为成员变量, 又名属性 动态特征提取出的概念称为成员函数, 又名方法 类与对象的关系 在代码中先有类后有对象 一个类可以有多个对象 多个对象可以属于同一个…概述
对象真实存在的事物
类 多个对象抽取其共同点形成的概念 静态特征提取出的概念称为成员变量, 又名属性 动态特征提取出的概念称为成员函数, 又名方法 类与对象的关系 在代码中先有类后有对象 一个类可以有多个对象 多个对象可以属于同一个类 类的定义
语法 class 类名 { [访问权限修饰符 :] 成员变量 成员函数 }; 访问权限修饰符 private 私有的 , 当前类中可用 , 默认的 protected 受保护的 , 当前类或子类中可用 public 公共的 , 当前项目中可用 示例
class Person{
private:int age;
protected:char sex[10];
public:char name[50];void eat(){cout name 吃饭 endl;}void sleep();
};
void Person::sleep()
{cout name 睡觉 endl;
}
类的对象
概念 类定义好之后, 可以通过类创建具体的对象创建的类的对象又称之为类的实例。 通过类创建的对象对象即具有类的属性数据和方法 语法 实例化对象 类名 对象名; 操作其中的成员 获取属性值 对象名.属性名 ; 修改属性值 对象名.属性名 值 ; 调用函数 对象名.函数名 ( 实参列表 ); 注意 : 以上对操作的成员, 必须在访问权限修饰符上得以满足 如在类外不能直接使用私有成员 示例
int main(int argc, char *argv[])
{
Person p1;
strcpy(p1.name,张三);
p1.eat();
p1.sleep();
return 0;
}
封装性 即包装 , 将数据和方法封装在一起 , 加以权限区分使其可以保护内部 , 降低耦合度 , 便于使 用 int a 10;
int nums[5] {1,2,3,4,5};
void fun()
{xxx
}
class A
{属性函数
}
A a;
x.c 优点 : 1,降低代码耦合度 2,提高代码复用率 3,编译使用 类的设计 1, 私有化所有属性 2, 提供可以获取这些属性值与修改属性值的函数 示例 class Stu
{
private:char name[50];char sex[10];int age;
public:char* get_name(){return name;}void set_name(char* n){strcpy(name,n);}char* get_sex(){return sex;}void set_sex(char* s){strcpy(sex,s);}int get_age(){return age;}void set_age(int a){age a;}void print_info(){cout 姓名: name \t性别: sex \t年龄: age endl;}
};
int main(int argc, char *argv[])
{Stu s;s.set_name(张三);s.set_sex(男);s.set_age(18);s.print_info();cout s.get_name() endl;cout s.get_sex() endl;cout s.get_age() endl;return 0;
} 构造函数
概念 构造函数 是类实例化对象的时候自动调用。 注意 : 当一个类中没有构造函数, 系统将默认为其生成一个无参构造如果一个类中有构造函数, 系统将不会为其提供默认的无参构造一个类可以定义多个构造函数, 该类中的多个构造函数为重载关系 无参构造 : 构造函数无形参列表 有参构造 : 构造函数有形参列表 语法 类名 ( 形参列表 ) { 该类对象赋初始值 } 注意 : 形参列表可有可无 示例
class Dog
{
private:char name[50];int age;
public:Dog(){cout 调用无参构造 endl;}Dog(char *n,int a){cout 调用有参构造 endl;strcpy(name,n);age a;}Dog(char *n){cout 调用一参构造 endl;strcpy(name,n);}
};
int main(int argc, char *argv[])
{
//隐式调用无参构造创建对象
Dog d1;
//显式调用无参构造创建对象
Dog d2 Dog();
//隐式调用有参构造创建对象
Dog d3(旺财,2);
//显式调用有参构造创建对象
Dog d4 Dog(富贵,1);
//如果构造函数只有一个参数,会发生构造函数的隐式转换知道就行
//隐式转换
//类名 对象名 值;
Dog d5 黑豹;
//匿名对象:创建的对象没有对象名
Dog();
Dog(无名);
return 0;
}
析构函数
概念 对象生命周期结束的时候 自动调用析构函数。 注意 : 一个类只能有一个析构函数 如果用户不提供析构函数 编译器默认会提供一个空的析构函数。 经验 : 一般不需要自定义析构函数, 但是如果类中有指针成员且指向堆区空间这时必须实现析构函数, 在其中释放指针成员指向的堆区空间 语法 ~ 类名 () { } 注意 : 没有形参列表 示例
class Cat{
private:char name[50];
public:Cat(char *n){strcpy(name,n);cout name 被创建了 endl;}~Cat(){cout name 被销毁了 endl;}
};
void test01()
{Cat c(布丁);
}
int main(int argc, char *argv[])
{test01();return 0;
}
多对象构造与析构顺序 示例 1: 对象 A 与对象 B 平级 , 符合栈的顺序 ( 先进后出 ), 谁先创建谁后释放 class Cat{
private:char name[50];
public:Cat(char *n){strcpy(name,n);cout name 被创建了 endl;}~Cat(){cout name 被销毁了 endl;}
};
void test01()
{Cat c1(布丁);Cat c2(乔巴);{Cat c3(可乐);Cat c4(雪碧);}
}
int main(int argc, char *argv[])
{test01();return 0;
} 结果 示例 2: 对象 A 是对象 B 的成员 , 先成员构造 , 在对象构造 , 在对象析构 , 在成员析构 class A{
public:
A(){cout A构造 endl;
}
~A()
{cout A析构 endl;
}
};
class B{
private:A a;
public:
B(){cout B构造 endl;
}
~B()
{cout B析构 endl;
}
};
int main(int argc, char *argv[])
{B b;return 0;
} 拷贝构造函数
概述 拷贝构造在以下情况自动触发 : 1,旧对象给新对象初始化 , 会调用拷贝构造函数 2,对象作为函数的形参 , 函数调用时会调用拷贝构造 3,普通对象作为函数的返回值 (vs 会触发拷贝构造 ,Qt 、 Linux 不会触发拷贝构造 ) 注意 : 如果用户不提供拷贝构造 编译器会提供一个默认的拷贝构造浅拷贝。 只有类中有指针成员且指向堆区时 才有必要实现拷贝构造深拷贝。 浅拷贝与深拷贝 浅拷贝: 当类中的成员有指针成员 , 此时只拷贝地址 深拷贝: 当类中的成员有指针成员 , 先开辟内存 ,在拷贝其值 语法 类名 (const 类名 ob) { } 示例 示例 1: 旧对象给新对象初始化 class Cat{
private:
char name[50];
public:
Cat(char *n)
{
strcpy(name,n);
cout name 被创建了 endl;
}
~Cat()
{
cout name 被销毁了 endl;
}
Cat(const Cat cat)
{
cout 拷贝构造被调用了 endl;
strcpy(name,cat.name);
}
};
int main(int argc, char *argv[])
{
Cat c1(布丁);
Cat c2 c1;
return 0;
} 示例 2: 对象作为函数的形参 , 函数调用时会调用拷贝构造 class Cat{
private:char name[50];
public:Cat(char *n){strcpy(name,n);cout name 被创建了 endl;}~Cat(){cout name 被销毁了 endl;}Cat(const Cat cat){cout 拷贝构造被调用了 endl;strcpy(name,cat.name);}
};
void test(Cat cat)
{
}
int main(int argc, char *argv[])
{Cat c1(布丁);test(c1);return 0;
} 示例 3: 普通对象作为函数的返回值 (vs 会触发拷贝构造 ,Qt 、 Linux 不会触发拷贝构造 ) class Cat{
private:char name[50];
public:
Cat(char *n)
{
strcpy(name,n);
cout name 被创建了 endl;
}
~Cat()
{
cout name 被销毁了 endl;
}
Cat(const Cat cat)
{
cout 拷贝构造被调用了 endl;
strcpy(name,cat.name);
}
};
Cat test()
{
Cat c1(布丁);
return c1;
}
int main(int argc, char *argv[])
{
Cat c test();
return 0;
} 浅拷贝 class Cat{
public:
char *name;
Cat(char *n)
{
name n;
cout name 被创建了 endl;
}
~Cat()
{
cout name 被销毁了 endl;
}
};
int main(int argc, char *argv[])
{
char name[10] Hi;
Cat c1(name);
Cat c2 c1;
c2.name[0] h;
cout c1.name c1.name endl;
cout c2.name c2.name endl;
return 0;
} 深拷贝 class Cat{
public:char *name;
Cat(char *n)
{name (char *)calloc(1,50);strcpy(name,n);cout name 被创建了 endl;
}
~Cat()
{cout name 被销毁了 endl;free(name);
}
Cat(const Cat cat)
{name (char *)calloc(1,50);strcpy(name,cat.name);
}
};
int main(int argc, char *argv[])
{char name[10] Hi;Cat c1(name);Cat c2 c1;c2.name[0] h;cout c1.name c1.name endl;cout c2.name c2.name endl;return 0;
} 初始化列表
概述 构造函数 : 主要用于创建类的对象是给其属性赋初始值 在定义构造函数时 C 中提供了初始化列表的语法 , 以便于初始化成员变量的值。 语法 类名 ( 参数列表 ): 成员名 ( 参数名 ), 成员名 2( 参数名 2),... { } 示例
示例1
class Data
{int a;int b;
public:
Data(int x,int y):b(y),a(x)
{
}
void print_data()
{cout a a endl;cout b b endl;
}
};
int main(int argc, char *argv[])
{Data d(10,1);d.print_data();return 0;
}
explicit关键字
作用 禁止隐式转换 语法 explicit 类名 ( 形参列表 ): 初始化列表 { } 示例
class C{
private:
int a;
public:
explicit C(int x):a(x){}
};
int main(int argc, char *argv[])
{
C c 10;//构造函数的隐式转换
//当调用构造函数使用explicit修饰后防止隐式转换,此时上述代码报错
return 0;
}
new与delete 情况 1: 操作基本类型 作用 new 申请堆区空间 delete 释放堆区空间。 示例 void fun01()
{
int *p1 new int;
*p1 100;
cout *p1 endl;
int *p2 new int(100);//给p2的值初始化为100
cout *p2 endl;
} 情况 2: 操作数组 作用 new 申请堆区空间 delete 释放堆区空间。 示例 void fun02()
{
int *nums new int[5];
cout nums[0] \t nums[1] endl;
delete [] nums;
int *ns new int[5]{11,22,33,44,55};
cout ns[0] \t ns[1] endl;
delete [] ns;
} 情况 3: 操作对象 作用 new: 分配空间 , 调用构造函数 delete: 调用析构函数 , 释放空间 示例 class D{
public:
D(){
cout D构造 endl;
}
~D(){
cout D析构 endl;
}
};
void fun03()
{
D *d new D();
delete d;
} 注意 malloc,calloc,free 只能申请或释放空间 , 不能调用构造函数或析构函数 new,delete, 既能申请或释放空间 , 又能调用构造函数或析构函数 所以建议不要使用 malloc,calloc,free 等函数了 对象数组 静态对象数组 示例 class A
{
public:
int mA;
public:
A()
{
coutA无参构造endl;
}
A(int a)
{
mA a;
coutA有参构造mAmAendl;
}
~A()
{
coutA析构函数mAmAendl;
}
};
void fun04()
{
//对象数组 必须显示调用构造函数初始化
A arr[5]{A(10),A(20),A(30),A(40),A(50)};
int n sizeof(arr)/sizeof(arr[0]);
int i0;
for(i0;in;i)
{
coutarr[i].mA ;
}
coutendl;
} 动态对象数组 示例 void fun05()
{
A *arr new A[5]{A(10),A(20),A(30),A(40),A(50)};
int i0;
for(i0;i5;i)
{
coutarr[i].mA ;
}
coutendl;
//delete arr;//只会释放第0个元素
delete [] arr;
} 静态成员 静态成员变量 概述 static修饰的成员为静态成员。 特点 : 静态成员是属于类而不是对象。所有对象共享 注意 : 静态成员数据不占对象的内存空间。 静态成员数据是属于类 而不是对象多有对象共享一份静态成员数据 静态成员数据在定义对象之前就存在。静态成员数据在类中定义, 类外初始化。 示例 class E{
public:
static int num;//类中定义静态成员
};
int E::num 100;
int main(int argc, char *argv[])
{
//使用类名访问
cout E::num E::num endl;
E e1;
E e2;
//使用对象名访问
cout e1.num e1.num endl;
cout e2.num e2.num endl;
e1.num 1;
//一个对其修改该类所有对象的静态成员都将被修改
cout E::num E::num endl;
cout e1.num e1.num endl;
cout e2.num e2.num endl;
return 0;
} 静态成员函数 概述 使用 static 修饰的成员函数 特点 : 静态成员函数只能访问静态成员数据 示例 class E{
private:
static int num;//类中定义静态成员
int x;
public:
static void set_num(int n)
{
num n;
cout 静态函数set_num被执行 endl;
}
static int get_num()
{
cout 静态函数get_num被执行 endl;
return num;
}
};
int E::num 100;
int main(int argc, char *argv[])
{
//使用类名调用
E::set_num(10);
int x E::get_num();
//使用对象调用
E e;
e.set_num(1);
return 0;
} 单例模式 概述 所属的类 只能实例化一个对象。 示例 : 懒汉式 class DL{
private:
static DL *dl;
DL(){}
DL(const DL d){}
public:
int x;
static DL* get_instance()
{
if(dl NULL)
{
dl new DL();
}
return dl;
}
};
DL *DL::dl NULL;
int main(int argc, char *argv[])
{
DL *d1 DL::get_instance();
DL *d2 DL::get_instance();
DL *d3 DL::get_instance();
d1-x 1;
d2-x 10;
d3-x 100;
cout d1.x d1-x endl;
cout d2.x d2-x endl;
cout d3.x d3-x endl;
return 0;
} 示例 : 饿汉式 class DL{
private:
static DL *dl;
DL(){}
DL(const DL d){}
public:
int x;
static DL* get_instance()
{
return dl;
}
};
DL *DL::dl new DL();
int main(int argc, char *argv[])
{
DL *d1 DL::get_instance();
DL *d2 DL::get_instance();
DL *d3 DL::get_instance();
d1-x 1;
d2-x 10;
d3-x 100;
cout d1.x d1-x endl;
cout d2.x d2-x endl;
cout d3.x d3-x endl;
return 0;
}
