Thinking in C++, Part I

最新推荐文章于 2024-05-28 21:13:10 发布
最新推荐文章于 2024-05-28 21:13:10 发布
阅读量3.6k 收藏 4
点赞数
分类专栏： Thinking in C++ 文章标签： c++ class 编译器 output float null
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/simonwan/article/details/354169
版权

Thinking in C++

1.     private 与 protect 关键字的区别。

子类能访问基类的protect成员而不能访问private成员。

2.     友元，friend 如何声明一个友元。

3.     缺省构造函数。当类声明了一个带参数的构造函数后而没有声明无参数构造函数，编译器还会为它生成一个默认的缺省构造函数吗？分析下例的错误：

class A{

public:

A(int i){

     cout<<i<<endl;

}

};

void main(){

    A a;

}

4.     构造函数有没有返回值？析构函数有没有返回值？析构函数可不可以带参数？

5.     解释一下重载

    函数重载允许两个或更多个函数使用同一个名字限制条件是它们的参数表必须不同参数类型不同或参数的数目不同。

6.     重载函数如何来区分彼此？

7.     解释缺省参数函数

8.     下例能编译通过吗？为什么。重载的缺省参数函数不能与其它函数产生二义。

void s(int i){

cout<<i<<endl;

}

void s(int i, int j=0){

cout<<i<<endl;

}

void main(){

    s(5);

}

9.     能否用返回值来区分重载函数？

10.  看下例回答以下问题：

a.     常量必须初始化，下面的代码又和问题：

   const int i;

i=20;

b.     常量有没有存储控件，或者只是编译时的符号而已？

不一定

c.     常量一定是在编译时就确定其值的吗？

const int i=100;

const int j=i+100;

long address=(long)&j; //强迫编译器为常量分配存储空间

char buf[j+10];

void main(){

    const char c=cin.get();

    const char c2=c-'a'+'A';

    cout<<c<<" "<<c2<<endl;

}

11.  看下例回答以下问题：

a.     能否将一个非常量对象的地址赋给一个常量指针？

b.     能否将一个常量对象的抵制赋给一个非常量指针？若确要如此，该如何做？

    void main(){

    const int i=5;

    int *j=const_cast<int *>(&i);

}

    const int* x;            //常量指针

int* const x=&d;         //指针常量

int const* x;            //常量指针

const int* const x=&d;   //常量指针常量

12.  函数调用中值传递使用常量定义无甚意义：

   void f(const int i);

   但函数返回值的常量定义有特殊作用，看下例：

    class X{

        int i;

public:

        void modify(){cout<<"haha"<<endl;}

};

const X fun(){return X();}

void main(){

        //! fun().modify(); 常量不能为左值，所以下例也不成立：

        //! const X g;

        //! g.modify();

        //!!!  常量一定不能为左值吗？ 看16题

}

13.  常量的典型应用：

    void u(const int* p);

const char* v();

14.  分析下例说出错误的原因：

    class X{};

X f(){return X();}

void g1(X&){}

void g2(const X&){}

void main(){

        //! g1(f());    临时变量都是常量

        g2(f());

}

15.  如何使用类常量成员，如何初始化？

class Y{

public:

    const size;

    Y();

};

Y::Y():size(100){}

class X{

    enum{i=100};

};

//!  class X{

//!      const int i;

//!      X(){};

//!  };

16.  将一个成员函数声明为常量函数有什么作用？

a. 编译器保证该函数不得修改成员变量的值

b. 允许一个常量对象调用此函数

class X{

public:

    void f() const{

         cout<<"haha..."<<endl;

   }

};

void main(){

   const X cs;

    cs.f();

}

17.  volatile关键字有什么作用？

volatile 告诉编译器不要对其做任何自作多情的假设与优化。比如建立一个 const volatile 的对象，告诉编译器程序员不得改变此对象，但不是说该对象不会发生改变，来自外界的工具可能会改变它，比如硬件的端口通信。

18.  内联函数与普通函数、宏的差别？

使用内联函数的地方，编译器会对其代码进行展开，而不是插入一个跳转。这样提高了函数调用的效率。内联函数不像宏，它是一个真正的函数，有参数类型检查。

注意：在“类中”定义的成员函数都是内联函数。

19.  哪两种情况会使编译器放弃内联？

a.     函数题太复杂

b.     代码中会显式或者隐式的确函数地址

20.  预处理器的特殊功能：

a.     #define DEBUG(X) cout<<#X"="<<X<<endl

b.     #define TRACE(X) cout<<#X<<endl,X

c.     #define FILE(X)  char* X##_string

使用：

int f(){

return 9;

}

void main(){

    char i[]="haha";

    DEBUG(i);

    for(int j=0;j<5;j++)

    TRACE(f());

    FILE(one)=i;

    cout<<one_string<<endl;

}

21.  有没有代码能在主函数的第一行代码之前或最后一行代码之后执行？

class Obj{

char cT;

public:

    Obj(char c){

         cT=c;

         cout<<"Obj::Obj()  for"<<c<<endl;

   }

    ~Obj(){

         cout<<"Obj::~Obj() for"<<cT<<endl;

    }

};

Obj A('A');

void f(){

static Obj B('B');

}

void main(){

    cout<<"inside  main()"<<endl;

    f();

    cout<<"leaving main()"<<endl;

}

OUTPUT:

Obj::Obj()  forA

inside  main()

Obj::Obj()  forB

leaving main()

Obj::~Obj() forB

Obj::~Obj() forA

22.  static 关键字的作用：

a.     静态存储

b.     控制可见性

以下都是全局定义的变量

extern int a=0;  ===>  int a=0;  (静态)

extern void f(); ===>  void f();

static int a=0;  ===>  本文件内可见 

static void f(); ===>  本文件内可见

23.  名字空间的使用：

namespace simon{

class A{

   public:

   void print(){

         cout<<"this is simon::A"<<endl;

     }

   };

char str[]="this is simon::str";

}

void main(){

simon::A v;

v.print();

using namespace simon;

cout<<str<<endl;

}

24.  静态成员函数与普通成员函数有什么区别？

静态成员函数只能访问静态成员变量与静态成员函数。为什么呢？想一想那个this指针，静态成员函数是没有this指针的。

25.  在C++中用到一个C库中的函数，为了防止编译器按照C++的方式对符号进行访问以致无法定位函数实体该如何做？

extern"C" float f(int a, float b);

c++中  f() ===> _f_int_float

c中   f() ===> _f

26.  如何改变一个指针常量的指向？

    void main(){

   int i(1);

   int j(2);

   int * const  p=&i;

   int * pp=(int*)&p;

   *pp=(int)&j;

   cout<<*p<<endl;

}

27.  解释下面例子错误的原因

const int iii=20;

int & q=iii; //错误，非常量引用不能引用常量

int & qq=20; //错误，非常量引用不能引用常量

const int & qqq=iii; //正确

qqq=23; //错误，常量不能作为左值

引用必须跟一块合法的存储空间联系起来。

a．引用必须被初始化

b. 引用一旦指向一个对象，就不能再指向其它

c. 不能引用NULL ，不能引用常量（除非是常量引用）

28.  当用引用作函数参数时，其参数必须是非常量，即不能是直接值或返回的临时变量

    void f(int &){}

void g(const int &){}

void main(){

//f(1);

g(1);

}

29.  什么情况下需要一个拷贝构造函数？

需要用类作值传递时

class X;

void f(X x2);

X x1;

f(x1);

X x2=x1;

30.  拷贝构造函数的形式： X::X(X&){}

31.  尽量避免类的值传递，用什么方法可以阻止用户的类值传递？

只要声明一个私有的拷贝构造函数即可：

class X{

X(X& x) {

     cout<<"hehe"<<endl;

}

public:

X(){}

};

void main(){

    X xx;

    //! X x2=xx; 

}

32.  定义一个函数指针，指向一个类的非静态成员函数，并调用：

class X;

typedef void (X::*FPT) ();

class X{

public:

int xi;

FPT pp;

X(int j){

     xi=j;

     pp=X::f;

     (this->*pp)();

}

void f(){

     cout<<xi<<endl;

}

};

void main(){

   X x1(1),x2(2);

   FPT p1,p2;

   p1=X::f;

   p2=x1.f;

   (x2.*p1)();

   (x2.*p2)();

}

注意，非静态的成员始终要跟this指针结合使用，要用一个对象来使用它而不是一个类型。即使是在类定义内部也要显式用this来强调这种关系。

33.  下例发生了几次拷贝构造函数调用？一次

    class X{

public:

        X(){}

        X(X&){

            cout<<"haha..."<<endl;

        }

};

void main(){

       X x1;

       X x2=x1;

       x2=x1;

}

34.  避免使用运算符重载！！！

35.  类成员运算符重载与全局运算符重载的区别？  参数的个数

36.  在继承链上，子类的构造函数需要显式的调用基类的构造函数，而析构函数呢？不需要，它们会被自动调用。语法：

foo::foo(int i):base_foo(i){...}

37.  什么是构造函数初始化列表？

构造函数的调用顺序是：先基类的构造函数，然后是成员对象的构造函数，构造顺序不受初始化列表中的排列顺序影响。同等级成员的初始化列表由其在类声明中的顺序决定。析构顺序与构造顺序相反。

38.  举例说明为什么有时候必须要初始化列表？

class Z{

public:

Z(int i)    {

     cout<<"huhu..."<<endl;

}

};

class X{

public:

    X(int i) {

         cout<<"hehe..."<<endl;

    }

};

class Y :public X{

public:

Z z1;

Y(int i):X(i),z1(6) {

     cout<<"haha..."<<endl;

}

};

void main(){

   Y y(5);

}

试试将上面例子的初始化列表移到函数体内部，会发生什么？

39.  基类中对函数foo进行了多次重载，子类中重定义函数foo，能否在子类中调用foo的基类版本？

不能，子类重定义将屏蔽所有基类版本。

class X{

public:

f(int i,int j)  {cout<<"haha"<<endl;}

f(int i){cout<<"haha"<<endl;}

};

class Y:public X{

public:

f(int i){cout<<"hehe"<<endl;}

};

void main(){

   Y y;

   //! y.f(3,4);

}

40.  谈谈public,private,protect关键字的区别

41.  谈谈私有继承的性质

42.  如何在子类中开放私有集成基类的借口

class X{

public:

void f(){cout<<"haha"<<endl;}

void ff(){cout<<"hehe"<<endl;}

};

class Y: X{

public:

X::f;

};

void main(){

   Y y;

   y.f();

   //！ y.ff();

}

43.  判断下列例子的输出：

class X{

public:

void foo()  {cout<<"X::foo"<<endl;}

};

class Y: public X{

public:

void foo()  {cout<<"Y::foo"<<endl;}

};

void bar(X* p){

p->foo();

}

void barbar(X& x){

x.foo();

}

void main(){

   Y y;

   X* p;

   X& m=y;

   p=&y;

   p->foo();

   bar(p);

   barbar(m);

}

要想通过p调用Y::foo()该怎么做？  利用virtual 实现多态

44.  晚捆绑。解释编译器是如何来做到晚捆绑的？

a.     为每个包含虚函数的类创建一个表（VTABLE）

b.     在该表中放置虚函数地址

c.     为每个有虚函数的类的对象放置一个指针：VPTR，指向响应的VTABLE

45.  class no_virtual{

int a;

void f(){};

};

class one_virtual{

int a;

virtual void f(){};

};

class only_virtual{

virtual void f(){};

};

class two_virtual{

virtual void f(){};

virtual void g(){};

};

class null{};

void main(){

cout<< sizeof(no_virtual)

     << sizeof(one_virtual)

     << sizeof(only_virtual)

     << sizeof(two_virtual)

     << sizeof(null)

     <<endl;

}

OUTPUT：48441    说明为什么是这个结果？

谈谈在one_virtual 中VPTR与 int a 的位置关系是怎么样的？

46.  每个有虚函数的类都有一个自己的VTABLE，画图解释继承链中的VTABLE关系

 

47.    

Instrument * i;

Brass B;

i = &B;

i->adjust(1);

写出最后一行的汇编代码：

28:       Instrument* pi;

29:       Brass B;

004010A 8 8D 4D F8             lea         ecx,[ebp-8]

004010AB E8 73 FF FF FF       call        @ILT+30(Brass::Brass) (00401023)

30:       pi=&B;

004010B0 8D 45 F 8             lea         eax,[ebp-8]

004010B3 89 45 FC             mov         dword ptr [ebp-4],eax

31:       pi->adjust(1);

004010B6 8B F4                mov         esi,esp

004010B8 6A 01                push        1

004010BA 8B 4D FC             mov         ecx,dword ptr [ebp-4] ；this指针

004010BD 8B 11                mov         edx,dword ptr [ecx] ；VPTR指针

004010BF 8B 4D FC             mov         ecx,dword ptr [ebp-4] ；作参数

004010C 2 FF 52 08             call        dword ptr [edx+8] ；取虚函数

非静态成员函数的调用都涉及到将this指针传递给函数

48.  什么是抽象基类，纯虚函数？

抽象基类可不可以有实例？ 不能

纯虚函数可不可以有实现？ 能

class X{

public:

virtual void f()=0  {

     cout<<"haha"<<endl;

}

};

49.  在派生类中增加新的虚函数，能不能用基类的指针调用之，为什么？请从VTPR与VTABLE的角度来解释。

如果此时确切的知道基类指针指向的是派生类对象，需要调用该函数，该如何做？RTTI

class X{

public:

virtual void f(){cout<<"haha"<<endl;}

};

class Y :public X{

public:

virtual void f(){cout<<"hehe"<<endl;}

virtual void ff(){cout<<"hehehehe"<<endl;}

};

void main(){

X* p;

Y y;

p=&y;

Y* py=NULL;

py=static_cast<Y*>(p);

if(py) py->ff();

}

50.  看下面的例子，谈谈为什么要避免值传递：

class X{

int xi;

public:

 X(int i){xi=i;}

virtual int f() {return xi; }

};

class Y :public X{

int yj;

public:

Y(int i, int j):X(i),yj(j){}

virtual int f() {return X::f()+yj;}

};

void call(X B){cout<<B.f()<<endl;}

void main(){

Y A(5,8);

call(A);

}

OUTPUT：5

类对象在进行值传递时发生了“对象切片”，无论是默认的拷贝构造函数还是手工提供的，编译器都会在其中放一段代码对VPTR进行初始化。这里call的参数类型声明为基类，则调用了基类的拷贝构造函数，将对象的VTPR指向了基类的VTABLE（原本应该指向派生类的VTABLE的）。于是错误发生了。

回忆一下，什么方法可以迫使程序员放弃值传递？  私有拷贝构造函数

51.  无论是手工提供的构造函数还是默认的构造函数，无论是拷贝构造函数还是一般构造函数，编译器都会在其中加上一段代码用以初始化VPTR（当然是有虚函数的类的构造函数）

52.  编译器插入到构造函数中的秘密代码一般有哪几部分？

a.     初始化VPTR（对于有虚函数的类来说）

b.     检查this指针（因为对象有可能没有构造成功，operator new）

c.     调用基类的构造函数（如果在派生类的初始化参数列表中没有显式的调用基类的构造函数，则编译器会自动调用基类的无参数构造函数（默认的或者手工的）即使派生类构造函数在函数体内部调用了基类构造函数也不例外，如果这时基类没有无参数构造函数（比如它只手工提供了带参数的构造函数）则编译出错）

class X{

public:

   X() {cout<<"X::X()"<<endl;}

    X(int i){cout<<"X::X(int)"<<endl;}

};

class Y :public X{

public:

    Y(int i){X(5);}

};

void main(){

   Y y(6);

}

OUTPUT：X::X()

X::X(int)

53.  说明下例为什么无法编译通过？

class X{

public:

    X(int i) {cout<<"X::X(int)"<<endl;}

};

class Y :public X{

public:

};

void main(){

Y y;

}

如何才能通过？

54.  上例中如果派生类改为：

class Y :public X{

public:

Y(){}

};

为何不能编译通过？如何修改？

规则：应该始终在初始化列表中调用基类构造函数

55.  如果在构造函数中调用了虚函数，只有虚函数的本地版本被调用。

class X{

public:

virtual void f(){cout<<"X::f"<<endl;}

    X()  {f();}

};

class Y : public X{

public:

virtual void f(){cout<<"Y::f"<<endl;}

    Y()  {f();}

};

class Z : public Y{

public:

virtual void f(){cout<<"Z::f"<<endl;}

    Z()  {f();}

};

void main(){

Z z;

}

OUTPUT：X::f

Y::f

Z::f

    Z的构造函数被调用时，编译器会先调用X的构造函数，然后是Y的，因为构造函数都会将对象的VPTR指向自己类型的VTABLE因此当构造到达X的构造函数体内时，VPTR是指向X的VTABLE的，因此调用的函数就是X版本的函数。

56.  构造函数能不能是虚函数？  不能。但试想用一个基类指针去析构一个派生类对象时会发生什么事情？  如何解决？   令析构函数为虚函数

规则：只要使用多态，就应该让析构函数为虚函数。

析构函数不需要像构造函数那样显式的调用基类的析构函数，编译器会自动调用基类的构造函数。

57.  讨论，若在析构函数中调用了虚函数，应该调用虚函数的哪个版本？  本地版。只有本地版才会只处理本地数据，不会去处理一个也许几经被“析构”的派生类数据。

因此晚捆绑机制在析构函数中被忽略。

58.  模板的语法

类模板：

template<class T>

class array{

T aT[100];

public:

     array() {for(int i=0;i<100;i++) aT[i]=(T)i;}

     T getAt(int index);

};

template<class T>

T array<T>::getAt(int index){return aT[index];}

void main(){

array<double> Darray;

    cout<<Darray.getAt(8)<<endl;

}

常量模板：

template<int size=100>

class array{

double aT[size];

public:

    array() {for(int i=0;i<size;i++) aT[i]=i;}

     double getAt(int index);

};

template<int size>

double array<size>::getAt(int index){return aT[index];}

void main(){

array<10> Darray;

cout<<Darray.getAt(8)<<endl;

array<> Dsarray;

    cout<<Dsarray.getAt(99)<<endl;

}

函数模板：

template<class T>

T Tgetmem(T* pT, int index){ return pT[index];}

void main(){

    double dd[100];

   for(int i=0;i<100; i++) dd[i]=i;

   cout<<Tgetmem(dd,5)<<endl;

}

59.  多重继承。应避免。当多重集成中出现菱形继承时：出现这种情况：

为了消除继承人中包含两个base类的实体，该如何？   虚拟继承

class base{};

class d1: virtual base{};

class d2: virtual base{};

class mi: public d1, public d2{};

60.  RTTI。一般我们将一个指针向上映射为一个基类指针，然后通过虚函数使用基类的接口。但是偶尔我们需要知道一个基类指针指向对象的确切类型，于是有了RTTI。

注意，RTTI依赖与驻留在虚函数表中的类型信息，所以在一个没有虚函数的类上使用RTTI是会出错的。

61.  RTTI的两种用法：

a.     得到类型的名字，或者比较类型，判断类型。

typeid，比如S是一个shape*  ===> typeid(*S).name()

b.     向下安全映射

shape* sp= new circle;

circle* cp= dynamic_cast<circle*>(sp);

if(cp) cout<<”cast successed”<<endl;

62.  注意：typeid中要传入的是对象本身，对于指针要去内容，对于引用直接传引用比如：

class X;

class Y: public X;

X* xp= new Y;

typeid(* xp)==typeid(Y);

typeid(xp)  ==typeid(X*);

63.  注意，void指针没有类型，因此RTTI对于void指针是无用的。

64.  RTTI可以让我们用一个多态指针来发现类型信息，但是应该尽可能的使用虚函数，而不是RTTI。

65.  解释一下RTTI的机制。

RTTI通过在VTABLE中放置一个额外的指针来实现的。这个指针指向一个typeinfo的结构体，typeid()其实就是通过VPTR来取typeinfo信息。

66.  C++的异常与Windows的结构化异常SHE不是一回事。

simonwan
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
thinking in c++
05-08
18 1.7.1 更好的异常规格说明 21 查看详细目录 book53.part1.rar http://www.shubulo.com/attachment.php?aid=35 book53.part2.rar http://www.shubulo.com/attachment.php?aid=36 Thinking in C++(2nd) ...
刷刷笔试题~（1）
nanaMasuda的博客
09-23 2524
1.print()函数是一个类的常成员函数，它无返回值，下列表示中正确的是() void print() const; 知识点： 常成员函数的说明格式如下： 类型说明符 函数名（参数表）const; 2.下列对于宏的描述，不正确的是:（A） 宏会带来性能的缺失 宏不进行类型检查 宏可以做到函数无法做到的功能 编译时宏的处理早于函数 知识点：宏只是预定义的函数
thinking in c++ part1
04-09
本书两个压缩分卷，此卷为第一分卷
thinking in c++ part2（完）
04-09
此资源分两个压缩分卷，此为第二压缩卷，也是最后一卷
thinking in c++(part3)
03-08
thinking in c++中文版（pdf） <br>接着part2的
Thinking in C++ 中文高清PDF版(part2）
11-07
由于附件限制，所以分成两卷，希望大家原谅。书我就不多介绍了。
C++ enum 和 string互转
一个大佬的博客
05-28 265
【代码】C++ enum 和 string互转。
C++：round函数用法
Solititude的博客
05-28 221
C++：round函数用法
【最新区块链论文录用资讯】CCF A—INFOCOM 2024 共17篇
软件工程小施同学 的专栏
05-28 903
详情：https://infocom2024.ieee-infocom.org/program/accepted-paper-list-main-conference。BR-DeFedRL：具有快速收敛和通信效率的拜占庭式鲁棒去中心化联邦强化学习。FileDES：一个安全、可扩展、简洁的基于区块链的去中心化加密存储网络。CRACKLE：具有次线性通信复杂性的基于扇区的快速 BFT 共识。通过可逆 GAN 实现高容量的基于区块链的通用隐写术框架。通过树图区块链的半异步去中心化联邦学习框架。
【C++】类与对象(上)
m0_73911405的博客
05-28 699
为什么会右边报错，左边不报错？
【如何在Qt C++中使用SSL和TLS加密传输数据？】
最新发布
m0_45463480的博客
05-28 118
在这个示例中，我们创建了一个简单的Qt应用程序，向指定的HTTPS地址发送请求，并显示响应。信号来处理响应数据。您可以从响应中读取数据并进行进一步处理。来配置SSL/TLS连接，包括对证书进行验证和加密要求等。为您要访问的实际URL，并根据需要进一步配置SSL策略。在发送请求之前，可设置SSL配置。确保您的Qt项目已经链接了网络模块（对象发送网络请求，并接收响应。对象指定要访问的URL。
关于C++的特殊类定制
m0_62126248的博客
05-28 125
C++的一些特殊性质的类如何进行设计
C++ CSV 中文 乱码 UTF-8 ANSI
cfl997
05-28 166
要正确读取包含中文字符的CSV文件，需要确保文件是以UTF-8编码保存的，并且在读取文件时正确处理编码。使用并设置其字节流的编码方式可以解决乱码问题。
【C++】vector的基本使用
qq_64818885的博客
05-28 698
💗💗⭐个人专栏——⭐💫点击关注🤩一起学习C语言💯💫。
【贪心算法】C++ 解决算法题：买卖股票 / K次取反 / 按身高排序 / 优势洗牌
卜及中的博客
05-28 638
贪心算法在每一步选择中都采取当前状态下最优决策的算法。贪心算法通常用来解决最优化问题，其在贪心算法中，我们并不总是考虑到未来可能发生的情况，而是只关注当前的最优选择。这种贪心选择性质使得贪心算法特别适合解决那些具有最优子结构性质的问题，即局部最优解能够推导出全局最优解的问题。需要注意的是，贪心算法并不适用于所有的问题，因为并非所有问题都具有最优子结构性质。在某些情况下，贪心算法得到的结果可能并不是全局最优解，而只是一个较好的解。因此，在应用贪心算法时，需要仔细分析问题的特性，以确定贪心算法是否适用于该问题。
C++(25): C++17探索：std::optional
tecsai的博客
05-28 182
std::optional是C++17标准引入的一个新的标准库组件。这是一个轻量级的容器，旨在以类型安全的方式包装可能为空的值。std::optional为处理可能缺失的数据提供了一种优雅而简洁的方法，这在以往通常需要使用专门的“存在”标志或复杂的错误处理机制。 简单点讲，std::optional在使用上并不复杂，主要用来替代那些需要返回NULL，或以返回-1表示错误等的场合。这样做最直观的一个改进就是易读性增强了。
【LinuxC语言】glob函数
m0_62599305的博客
05-22 63
在Linux系统编程中，经常需要操作文件和目录，尤其是处理文件名模式匹配的情况，例如查找特定类型的文件或批量处理文件。C语言标准库提供了glob函数来满足这种需求，它能够根据指定的模式匹配文件名，并将结果存储在一个结构体中，方便程序员进行后续处理。本文将详细介绍glob函数及其相关函数globfree，并提供示例代码以展示其用法。glob函数用于根据指定的模式匹配文件名，并将匹配结果存储在一个glob_t结构中。以下是globglobfree函数用于释放由glob函数分配的内存，以避免内存泄漏。glob。
c++参数 使用笔记
jacke121的专栏
05-28 96
c++参数 使用笔记

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值