目录
[面试题:c/c++ static的作用?](#面试题:c/c++ static的作用?)
[为什么可以创建出 objx](#为什么可以创建出 objx)
1、柔性数组:



cpp
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<iostream>
using namespace std;
class MyString
{
private:
struct StrNode
{
int refcount; //引用计数
int slen;
int capa;
char data[0]; //数组不填或填0就成为柔性数组
};
private:
StrNode* pstr;
static const size_t DAFAUSIZE = 32;
static const size_t INCSIZE = 2;
static StrNode* GetMem(rsize_t n)
{
size_t total = (n > DAFAUSIZE) ? n + 1 : DAFAUSIZE;
StrNode* s = (StrNode*)malloc(sizeof(StrNode) + sizeof(char) * total);
memset(s, 0, sizeof(StrNode) + sizeof(char) * total);
s->capa = total - 1;
return s;
}
static void FreeMem(StrNode *p)
{
free(p);
}
public:
MyString(const char* p = nullptr) :pstr(nullptr)
{
if (p != nullptr)
{
int len = strlen(p);
pstr = GetMem(len);
pstr->refcount = 1;
pstr->slen = len;
strcpy(pstr->data, p);
}
}
MyString(const MyString &st) :pstr(st.pstr) //st给当前对象
{
if (pstr != nullptr)
{
pstr->refcount += 1; //+1 说明有两个对象持有这块空间
}
}
MyString(MyString &&st) :pstr(st.pstr) //移动构造
{
st.pstr = nullptr;
}
~MyString() {
if (pstr != nullptr && --pstr->refcount == 0)
{
FreeMem(pstr);
}
pstr = nullptr;
}
ostream& operator<<(ostream& out)const
{
if (pstr != nullptr)
{
out << pstr->data;
}
return out;
}
};
ostream &operator<<(ostream &out, const MyString &st)
{
return st << out;
}
int main()
{
MyString s1 = "chengxi";
MyString s2(s1);
MyString s3(s2);
MyString s4(s3);
cout << s3 << endl;
return 0;
}
2、友元函数:
(1)不具有传递特性、继承特性、是单向的。
(2)友元函数分为:函数友元、成员函数友元、类友元
(3)友元函数是访问类的对象非公有属性。
成员函数友元:
cpp
using namespace std;
class Base;
class Test
{
private:int sum;
public:
Test(int x = 0) :sum(x) {}
void SetSum(int x = 0)
{
sum = x;
}
int GetSum()const { return sum; }
int Add(const Base &it);
};
class Base
{
friend int Test::Add(const Base& it);//成员函数友元
int num;
public:
Base(int x = 0) :num(x)
{
}
};
int Test::Add(const Base& it)
{
return this->sum + it.num;
}
int main()
{
Test t1(100);
Base b1(2);
t1.Add(b1);
}
类友元:
cpp
using namespace std;
//Test对象访问base的私有和公有,注意方向
class Base
{
friend class Test;
private:
int num;
public:
Base(int x = 0) :num(x)
{
}
};
class Test
{
private:int sum;
public:
Test(int x = 0) :sum(x) {}
void SetSum(int x = 0){ sum = x;}
int GetSum()const { return sum; }
int Add(const Base &it) {
return it.num + 10;
}
int func(const Base& it)
{
return it.num;
}
};
int main()
{
Test t1;
Base b1;
t1.Add(b1);
t1.func(b1);
return 0;
}
3、静态成员
(1) 类静态成员只能在类外进行初始化,
(2)静态成员变量在数据区存储。静态量不属于对象,是被所有对象共享,不管有多少个对象,静态成员只有一份存在于数据区。
(3)静态数据可以在普通方法中使用
(4)为什么不能在参数列表中对静态成员初始化?
答:参数列表,在定义对象的时候要调用构造函数,拿参数列表对数据成员进行创建,静态成员被所有对象共享,在定义不同的对象时都要对静态成员进行构建,c++中,数据成员(对象、变量)在生存期内只能被构建一次。放在参数列表中,被构建了n次,不允许。要在类外进行初始化。
静态成员在类模版中,数据类型不同 ,就会产生不同的 "静态成员"
cpp
using namespace std;
template<class T>
class Object
{
private:
int value;
protected:
static int num;
public:
Object(int x=0):value(x){}
~Object(){}
};
class Test :public Object<Test>
{
public:
Test()
{
cout << "Create Test::" << (num += 1) << endl;
}
};
class Base :public Object<Base>
{
public:
Base() {
cout << "Create Base:" << (num += 1) << endl;
}
};
template<class T>
int Object<T>::num = 0;
int main() {
Test t1[1];
Base b1[2];
return 0;
}

Test t1[1];
:创建一个包含 1 个Test
对象的数组,在创建Test
对象时,会调用Test
类的构造函数,输出相应的信息。Base b1[2];
:创建一个包含 2 个Base
对象的数组,在创建Base
对象时,会调用Base
类的构造函数,输出相应的信息。注意事项
由于
Object
类的静态成员变量num
是模板化的,Object<Test>
和Object<Base>
是不同的模板实例化,它们各自拥有独立的num
副本。所以在创建Test
和Base
对象时,它们的num
计数是相互独立的。面试题
C语言:
(1)静态关键字修饰全局/局部变量,存在于数据区,当函数消亡时,静态变量还存在,可以&。
全局变量有static和无的区别?
(2)全局静态变量只在本文件中可见,同一工程的其他文件不可见, (私有),未用static修饰的全局变量,可以用extern在其他文件用。
(3)static修饰函数,此函数只在当前文件夹有效,在其他文件中不能用,(私有)。修饰函数本身而不是修饰返回值 static int* add() {} ,。
C++:
(1)static可以修饰类的成员,要在类外进行初始化。所有的对象都共享同一个静态成员变量,派生的类也共享(但前提是将其设置成protected /public)。
(2)静态成员变量不属于对象,无this,在常方法中可以修改静态成员变量的值,this不修饰它。
static可以修饰属性的类型,要在类外进行初始化,如果是静态常性变量可以在类内进行初始化,但必须要求是整型类型。
(3)static修饰成员方法,static void func(){} 无this指针。静态成员方法无this。
(3)static修饰的成员方法可以访问静态属性也可以访问非静态属性(非静态属性必须把对象传进来)。
静态成员方法可以通过 对象访问,也可以通过类名。
静态成员变量
- 类的所有对象共享:静态成员变量属于类本身,而不是类的某个对象。无论创建多少个类的对象,静态成员变量都只有一份副本,被所有对象共享。
- 需要在类外初始化:静态成员变量必须在类外进行初始化,因为它不依赖于对象的创建。
:obja可以创建出来,指针:4字节

cpp
#include<stdio.h>
#include<iostream>
using namespace std;
class Object
{
private:
int value;
private:
static Object objx;
private:
Object(int x = 0) :value(x) {cout << "create Obj" << this << endl;}
~Object(){cout << "destroy obj:" << this << endl;}
};
Object Object::objx(1);
int main()
{
return 0;
}

成员变量 :
int value;
:一个私有成员变量,用于存储对象的值。static Object objx;
:一个私有静态成员变量,类型为Object
类本身。静态成员变量属于类,而不是类的某个对象,所有该类的对象共享同一个静态成员变量。静态成员变量初始化
*
Object Object::objx(1);
这行代码对
Object
类的静态成员变量objx
进行初始化,调用了Object
类的构造函数,并将参数1
传递给构造函数,将value
成员变量初始化为1
。为什么可以创建出
objx
虽然 Object 类的构造函数和析构函数都是私有的,通常情况下,外部代码无法直接创建 Object 类的对象。但是,静态成员变量 objx 是类的一部分,类的内部可以访问其私有成员。因此,在类的外部对静态成员变量 objx 进行初始化时,实际上是在类的作用域内调用了构造函数,这是被允许的。
当程序开始执行时,在进入 main 函数之前,会先对静态成员变量进行初始化,所以 Object::objx 会被创建,调用构造函数输出创建信息。当程序结束时,静态对象 objx 会被销毁,调用析构函数输出销毁信息。
cpp
using namespace std;
class Object
{
private:
int value;
private:
static Object objx;
private:
Object(int x = 0) :value(x) {cout << "create Obj" << this << endl;}
~Object(){cout << "destroy obj:" << this << endl;}
public:
void Print()const { cout << "value" << value << endl; }
void SetValue(int x) { value = x; }
int GetValue()const { return value; }
//通过静态方法将静态对象的地址返回
static Object* getObject()
{
return &objx;
}
};
Object Object::objx(1);
int main()
{
Object* pa = Object::getObject();
Object* pb = Object::getObject();
if (pa == pb) { cout << "pa,pb pinter:object" << endl; }
pa->Print();
pa->SetValue(100);
pa->GetValue();
pa->Print();
return 0;
}
if (pa == pb) { cout << "pa,pb pinter:object" << endl; }
:比较pa
和pb
的值,如果相等,说明它们指向同一个对象,输出相应信息。由于objx
是静态对象,无论调用多少次getObject()
函数,返回的都是同一个对象的地址,所以pa
和pb
相等。- 通过静态成员函数可以在类外部访问私有静态成员对象,并且由于静态成员对象只有一个实例,无论通过多少个指针访问,操作的都是同一个对象。
4、对象与对象之间的关系
依赖关系:用-------> 表示
一个对象在运行期间会用到另一个对象的关系,通常在运行期间产生,并且伴随运行时的变化依赖关系也发生变化。主要表现为 :"使用关系"。
关联关系:用------> 表示:
静态关系,如:学生和学校,是关联关系
在设计中。关联关系主要体现在目标类型的指针或引用。
聚合、继承、组合等。
5、类模版
template<类型模版参数表>
类模板不是类,因此无法直接实例化对象,需要在声明类时给定确定的数据类型,编译器才会以此分配内存。对于普通类而言,类的声明和类成员函数的定义可以写在不同的文件中,但是对于类模板来说,最好定义在同一个文件中。
//define _N 10
template<class T,int N>
class SeqStack
{
T* data;
int capa;
int top;
static const int stackinitsize = 100;
static const int incsize = 2;
static T* GetMen(size_t sz)
{
T* newdata = (T*)malloc(sizeof(T) * sz);
if (nullptr == newdata)
{
cout << "malloc fail" << endl;
exit(1);
}
memset(newdata, 0, sizeof(T) * sz);
return newdata;
}
static void FreeMem(T* p)
{
free(p);
}
public:
SeqStack(int sz = stackinitsize) :data(nullptr), capa(sz), top(-1)
{
//data = (T*)malloc(sizeof(T) * capa); //只申请空间不构建对象
data = GetMen(capa);
}
~SeqStack()
{
}
int size()const { return top + 1; }
bool empty()const { return size() == 0; }
int capacity()const { return capa; }
bool full()const { return size() == capacity(); }
bool push(const T& x)
{
if (full())return false; //满了调增容函数
top += 1;
new(&data[top]) T(x); //data[++top] = x;构建对象
return true;
}
bool gettop(T *val) {
if (empty())return false;
val = data[top];
return true;
}
bool poptop(T& val)
{
if (empty())return false;
val = data[top];
(&data[top])->~T(); //析构top中的对象
top -= 1;
return true;
}
bool pop()
{
if (empty())return false;
(&data[top])->T();
top -= -1;
return true;
}
};
int main()
{
SeqStack<int, 10> istack; //using T:int N:10
}
int main() {
ClassName<int> intObj(10); // 实例化类模板,创建一个处理 int 类型的类对象
int result = intObj.getData();
std::cout << "Result: " << result << std::endl;
ClassName<double> doubleObj(3.14); // 实例化类模板,创建一个处理 double 类型的类对象
double dResult = doubleObj.getData();
std::cout << "Result: " << dResult << std::endl;
return 0;
}