可变的参数:三个...表示
用可变的参数进行求和
#include<stdarg.h>
using namespace std;
int sum(int count...){
va_list ap;
//可变参数开始方法，count代表可以从哪里开始
va_start(ap, count);//count以后都是可变的参数
int sum = 0;
for (int i = 0; i < count; i++)
{
sum += va_arg(ap, int);
}
//结尾
va_end(ap);
return sum;
}
void main(){
int count=sum(2, 3, 5,4);//结果是8
cout << count << endl;
getchar();
}
static关键字
- 静态可以直接用类名去操作
- 静态的属性必须进行初始化
- 静态的方法只能去操作静态的属性或者方法
- 非静态的方法可以调用静态的方法
class Student
{
private:
char *name;
int age;
public:
//静态属性在c++中必须初始化
static int tag;
public:
static void change(){
tag += 12;
}
};
//静态属性在c++中必须初始化,而初始化必须这么写
int Student::tag = 12;
void main(){
Student stu;
//Student::tag = 14;//重新赋值
stu.change();
cout << stu.tag << endl;
getchar();
}
对象的大小
- 1.对象的大小和结构体的计算方式类似
- 2.static静态变量和方法并没有算到类的大小中
- 3.堆，栈，全局(静态，常量，字符串)，代码区，类的大小只与普通属性有关
class A{
public:
double b;
int a;
char c;
static double d;
//this指针
A(int a){
this->a = a;
}
public:
int getA(){
return this->a;
}
};
void main(){
cout << "对象A的大小是:" << sizeof(A) << endl;
A a1(12);
cout << "类A中的a1的值:" << a1.getA() << endl;
A a2(24);
cout << "类A中的a2的值:" << a2.getA() << endl;
getchar();
}
this的指针，代表当前的对象，因为类的方法存放在代码区，而代码区是共享的，所以要用this对其进行区分
const修饰函数
class Student
{
private:
char *name;
int age;
public:
void change()const{//const放在()之后主要用来限制this关键字,
//age += 12;
}
const void change(){//const放在()之前无影响，无需关注
age += 12;
}
};
void main(){
Student stu;
stu.change();
getchar();
}
const Student *const this
第一个const 常量指针，代表值不可以修改
第二个const指针常量，代表指针的地址不能修改
友元函数
在类的内部才能访问私有函数,如果该方法声明成友元函数那么是可以在外部访问私有属性
class Person{
private:
int age;
public:
Person(int age){
this->age = age;
}
int getAge(){
return this->age;
}
//友元函数的声明
friend void Person_test(Person *person, int age);
};
//友元函数的实现
void Person_test(Person *person,int age){
person->age = age;
}
void main(){
Person person=Person(2);
Person_test(&person, 24);
cout << person.getAge() << endl;
getchar();
}
友元类
class A{
public ://B是A的友元类
friend class B;
private:
int age;
};
class B{
public:
A a;
void changeA(int newAge){
a.age = newAge;
}
int getA(){
return a.age;
}
};
void main(){
B b;
b.changeA(27);
cout << "a的age是:" << b.getA() << endl;
getchar();
}
案例
我们都知道真正的开发过程中我们的 cpp 或者 c 文件，最终 都是以dll 或者 so 库供调用者使用，所以为了确保类能够正常被调用，我们一般需要定义 .h 头文件，这时候我们可以对以上代码进行修改，首先定义一个Student.h文件
#ifndef STUDENT_H
#define STUDENT_H
class Student{
private://私有
char *name;
int age;
public:
//静态属性的声明
static int tag;
public:
Student();
Student(char*name);
Student(char*name, int age);
//析构函数:动态申请的时候需要释放内存
~Student();
//拷贝函数
Student(const Student &stu);
public:
void setAge(int age);
void setName(char*name);
int getAge();
char* getName();
void print()const;
//静态和友元函数
static void changeTag(int tag);
friend void changeAge(Student *student,int age);
};
#endif;//STUDENT_H
Student.cpp文件
#include<iostream>
#include "Student.h"
//静态属性初始化
int Student::tag = 0;
//构造函数
Student::Student(char*name):age(0){//age赋默认值
this->name = name;
}
Student::Student(char*name,int age) {
this->name = name;
this->age = age;
}
//析构函数:动态申请的时候需要释放内存
Student::~Student(){
};
//拷贝构造函数
Student::Student(const Student &stu){
};
//普通方法
void Student::setName(char*name){
this->name = name;
}
void Student::setAge(int age){
this->age = age;
}
int Student::getAge(){
return age;
}
char* Student::getName(){
return this->name;
}
void Student::print()const{
std::cout << this->name << "的年龄是:" << this ->age<<std::endl;
}
//静态和友元函数
void Student::changeTag(int tag1){
tag = tag1;
};
//实现友元方法，不需要添加Student::#
void changeAge(Student *student, int age){
student->age = age;
};
main函数中调用
void main(){
Student *stu=new Student("Peakmain",25);
Student::changeTag(24);
changeAge(stu,28);
stu->print();
getchar();
}
网友评论