C++ 疑难点

最新推荐文章于 2024-11-06 23:10:00 发布
最新推荐文章于 2024-11-06 23:10:00 发布
阅读量575 收藏 12
点赞数 5
分类专栏： c++ 文章标签： c++ 开发语言 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_67623521/article/details/136584540
版权

C++疑难点

this指针

调用成员函数时，成员函数通过一个名为 this 的隐式参数来访问调用它的那个对象，用请求该函数的对象地址初始化 this ，this 的指向总是自己这个对象，所以 this 是一个常量指针

Box* get_address()   //得到this的地址
{
	return this;
}
Box* get_address()   //得到this的地址
{
	Box box;
	this = &box; // error: lvalue required as left operand of assignment
    return this;
}

友元函数和运算符重载

#include <iostream>
#include <cmath>
using namespace std;

class MyInteger
{
public:
	MyInteger() { this->num_ = 0; }
	MyInteger(int num) : num_(num) {}
	MyInteger operator+(const MyInteger &other)
	{
		MyInteger temp;
		temp.num_ = this->num_ + other.num_;
		// this->num_ += m.num_; 		// 这违反了加法运算符的语义，加法运算通常是创建一个新的对象来保存结果，而不是改变原始对象。
		return temp;
	}

	MyInteger operator+(const int &other) // 运算符重载
	{
		MyInteger temp;
		temp.num_ = this->num_ + other;
		return temp;
	}

	MyInteger operator+=(const MyInteger &other)
	{
		MyInteger temp;
		temp.num_ = this->num_ + other.num_;
		return temp;
	}

	MyInteger operator+=(const int &other)
	{
		MyInteger temp;
		temp.num_ = this->num_ + other;
		return temp;
	}

	MyInteger &operator++()
	{
		++num_;
		return *this;
	}

	MyInteger operator++(int)
	{
		MyInteger temp(*this);
		num_++;
		return temp;
	}

	MyInteger &operator=(const MyInteger &myInteger) // 注意深浅拷贝问题
	{
		num_ = myInteger.num_;
	}

	friend ostream &operator<<(ostream &out, const MyInteger &myInteger); // 重载左移运算符 没加 const ，cout << m++;报错

private:
	int num_;
};

ostream &operator<<(ostream &out, const MyInteger &myInteger)
{
	out << myInteger.num_;
	return out;
}

void test01()
{
	MyInteger m;
	MyInteger m1(10);
	m1 = m + m1;
	cout << m << endl;
	cout << m1 << endl;
}

void test02()
{
	MyInteger m(1);
	MyInteger m1(100);
	m = m1 + m;
	m1 += 10;
	cout << m << " " << m1 << endl;
}

void test03()
{
	MyInteger m(2);
	MyInteger m1(8);
	// cout << ++(++m) << " " << ++m1 << endl;
	// cout << m << " ";
	cout << m++;
	cout << m;
}

int main()
{
	// test01();
	// test02();
	test03();
	// int a=1;
	// int b=2;
	// a=a+b;
	// cout<<a<<" "<<b<<endl;
	int c = 1;
	cout << endl;
	cout << c++ << endl;
	cout << c << endl;
	return 0;
}

不能重载的运算符

.，:: ，?:，sizeof，typeid，.* 这几个运算符不能被重载

C++编译器至少给一个类提供四个函数

1、构造函数

2、析构函数

3、拷贝构造函数

4、operator= 函数

多态的实现

多态实现的前提三个条件

1、必须是共有继承

2、通过基类指针指向派生类，并且访问派生类重写的方法。

3、基类中的被重写的方法是虚函数

这种技术让父类指针有多种形态，是一种泛型技术，直到运行时才决定执行哪个版本的函数。所谓泛型技术，就是使用不变的代码来实现可变的算法。多态中没有重写的函数是没有意义的。

水能载舟，亦能覆舟。多态也涉及了安全性的问题，

首先是无法访问子类中自己的虚函数，如Base * base=new Derived(); base->f1();编译时不会通过的（其中f1()是子类自己的虚函数，父类没有）；

然后是如果父类中虚函数是private或者protected，这些函数依旧会存在于虚函数表中，可以通过多态的方式来访问。

#include <iostream>
using namespace std;
class Father
{
public:
    virtual void f(){
        cout<<"hello Father!"<<endl;
    }
};

class Son : public Father
{
public:
    void f(){
        cout << "hello Son!"<<endl;
    }
};

int main() {
    Son s;
    Father *p = &s;
    p->f();

    Father f;
    p=&f;
    p->f();

    return 0;
}

菱形继承的问题

继承关系画成图像一个菱形，所以就叫做菱形继承，采用虚继承来解决二义性问题。

虚析构

总的来说是为了避免内存泄漏，当子类中有指针成员变量时才会使用到。也就是说，虚析构函数使得删除指向子类的父类指针时，不仅可以调用父类的的析构函数，也会调用子类的析构函数，这样就可以释放子类指针成员变量在堆中的内存，达到防止内存泄漏的目的。

#include <bits/stdc++.h>
using namespace std;
class CA
{
public:
    CA() { cout << "CA" << endl; }
    virtual void f1()
    {
        cout << "CA::f1( )" << endl;
        // f2();
    }
    void f2()
    {
        cout << "CA::f2( )" << endl;
    }
    virtual ~CA()
    {
        cout << "~CA" << endl;
    }
};
class CB : public CA
{
public:
    CB() { cout << "CB" << endl; }

    virtual void f1()
    {
        cout << "CB::f1( )" << endl;
    }
    void f2()
    {
        cout << "CB::f2( )" << endl;
    }
    virtual ~CB()
    {
        cout << "~CB" << endl;
    }
};
class CC : public CB
{
public:
    CC() { cout << "CC" << endl; }

    void f1()
    {
        cout<<"CC:f1()"<<endl;
    }
    void f2()
    {
        cout << "CC:f2()" << endl;
    }
    virtual ~CC()
    {
        cout << "~CC" << endl;
    }
};
int main()
{
    CA *pA = new CC();
    pA->f1();
    delete pA;
    CA *pA1 = new CB();
    pA1->f1();
    delete pA;
    return 0;
}//注意看构造和析构的顺序，正好是相反的

g++和gcc的区别

面试的时候，问到了gcc和g++的区别，没答上来：

首先说明：gcc 和 GCC 是两个不同的东西

GCC:GNU Compiler Collection(GNU 编译器集合)，它可以编译C、C++、JAV、Fortran、Pascal、Object-C、Ada等语言。

gcc是GCC中的GNU C Compiler（C 编译器）

g++是GCC中的GNU C++ Compiler（C++编译器）

​ 一个有趣的事实就是，就本质而言，gcc和g++并不是编译器，也不是编译器的集合，它们只是一种驱动器，根据参数中要编译的文件的类型，调用对应的GUN编译器而已，比如，用gcc编译一个c文件的话，会有以下几个步骤：

​ Step1：Call a preprocessor, like cpp.

​ Step2：Call an actual compiler, like cc or cc1.

​ Step3：Call an assembler, like as.

​ Step4：Call a linker, like ld

​ 由于编译器是可以更换的，所以gcc不仅仅可以编译C文件

​ 所以，更准确的说法是：gcc调用了C compiler，而g++调用了C++ compiler

​ gcc和g++的主要区别：

  1. 对于 .c和.cpp文件，gcc分别当做c和cpp文件编译（c和cpp的语法强度是不一样的）

  2. 对于 .c和.cpp文件，g++则统一当做cpp文件编译

  3. 使用g++编译文件时，g++会自动链接标准库STL，而gcc不会自动链接STL

  4. gcc在编译C文件时，可使用的预定义宏是比较少的

  5. gcc在编译cpp文件时/g++在编译c文件和cpp文件时（这时候gcc和g++调用的都是cpp文件的编译器）

关于内联函数

一般是加快程序执行速度，可能减小可执行文件大小，可能增加可执行文件大小。

速度快：当函数体较短时，内敛函数会像宏一样展开，所以执行速度比一般函数要快。但是如果函数体过大，一般的编译器会放弃内联方式，意思就是你使用内联函数，只不过是向编译器提出了一个申请，编译器可以拒绝，这个函数又会像普通函数一样，执行效率也和普通函数一样。

减小可执行文件大小：内联函数适度

增加可执行文件大小：内联函数过多

仿函数

在c++中仿函数（Functor）是一个类或者结构体，重载了函数调用运算符()，它的主要作用是提供一种更加灵活的函数对象，它可以包含状态信息，并且可以被传递给算法或者函数，从而实现定制的行为。比如实现排序准则、查找准则、谓词（就是一个bool返回值的函数）

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

void Print(int val){cout<<val<<" ";}
class Print1
{
public:
    void operator()(int val){cout<<val<<" ";}
};

void test01()
{
    vector<int> v;
    v.push_back(6);
    v.push_back(66);
    for_each(v.begin(), v.end(), Print1());
    cout<<endl<<"--------------"<<endl;
    for_each(v.begin(), v.end(), Print);
}

int main()
{
    test01();
    return 0;
}

pointer-like-class的作用

pointer-like-class是指类似指针的类，这种类一般用来模拟指针的行为，但是与裸指针相比具有更多的功能和安全性，如智能指针（Smart Pointers）、迭代器（Iterators）。Smart Pointers有std::unique_ptr和std::shared_ptr、std::weak_ptr。

一：结构化程序设计方法

位运算及其运用

判断奇数还是偶数

int a=11;
int b=1;
if(b&a){
	cout << "is odd" <<endl;
}else{
	cout<< "is even" <<endl;
}

取出指定的位

int a=0b11101101;
int b=0b1111;
cout << bitset<sizeof(char)*8>(a&b)<<endl;

判断是否为2的整数幂（0b10 0000 & 0b01 1111），结果是0，说明是2的整数幂。

int x = 64;
int y = x - 1;
cout << ((x & y) ? "no" : "yes") << endl;

指针数组与指向数组的指针的概念与使用

a是一个指向含有三个int型数据数组的指针（如有int p[3]; a指向p是可以的 ）

a1是一个函数三个int*型数据的数组（如a1可以初始化为{&b, &c, &d}）;

#include <iostream>
#include <typeinfo>
using namespace std;
#define sz(type) cout<<sizeof(type)<<endl;
int main(){
	int b=10, c=1, d=2;
	int (*a)[3];
	int* a1[3];
 	cout<<typeid(a).name()<<endl;
 	sz(a);
 	sz(a1);
 	sz(a1[0]);
 	sz(*a)
 	sz(a[0][0])
	return 0;
}

引用的分类与使用

1、初始化，定义引用时需要加&，

int a=1;
int &b=a;//相当于给a取了一个别名

2、作为函数参数传递，c++在函数参数中传递数组时，直接变成了指针，因为如果将数组传递过去需要将值一个一个拷贝过去，增加了函数调用的开销，所以在 C++ 中，我们有了一种比指针更加便捷的传递聚合类型数据的方式，那就是引用（Reference），通过这种方式传过去减少了生成副本的消耗。

void swap(int &a, int &b){
	int temp=a;
	a=b;
	b=temp;
}

3、作为函数返回值来传递，例如重载左移运算符，需要输出多个内容就需要返回引用。

#include <iostream>
#include <typeinfo>
using namespace std;
#define sz(type) cout << sizeof(type) << endl;
int function1(int &aa) // 以返回值的方法返回函数值
{
	return aa;
}
int &function2(int &aa) // 以引用方式返回函数值
{
	return aa;
}
int main()
{
	int a = 10;
	// 第一种情况，系统生成要返回值的副本（即临时变量）
	int b = function1(a); // function1()的返回值先储存在一个a的副本中，
						  // 然后再把副本赋值给b
	// 第二种情况，报错
	//  function1(a) = 20;// function1()的返回值为临时变量，不能赋值（即不能为左值）
	// 第三种情况，系统不会生成返回值的副本
	function2(a) = 20; // OK  此时a的值变成了20
	cout<<a<<endl;
}

重载左移运算符，返回引用才会连续输出两个值；

#include <iostream>
using namespace std;

class Point
{
public:
    int x_, y_;
    Point(int x, int y) : x_(x), y_(y) {}

    friend ostream &operator<<(ostream &os, const Point &p)
    {
        os << p.x_ << " " << p.y_ << endl;
        return os;
    }
};

int main()
{
    Point p(1, 2);
    cout<<p<<p;

    return 0;
}

变量的作用域和生命周期

c++的内存主要分为一下几个部分：栈区、堆区、全局区（静态区）、文字常量区、程序代码区。

全局变量

存储在静态内存分配区，整个程序的生命周期都可以使用，其他文件使用关键字extern也可以使用

局部变量

存储在栈区，与函数共存亡

全局静态变量

与全局变量类似，也是存储在静态内存分配区，生命周期与整个程序同在，不过不能再其他文件使用。

局部静态变量

也是存储在静态内存分配区，调用函数后便一直存在，只不过只能在函数内可见。

类型别名与类型推断

1、别名：typedef、using

2、推断：auto、decltype

STL顺序容器

vector：视作可变大小的数组，可随机访问，在非尾部的位置插入比较慢

deque：双端队列，支持随机访问，在头尾位置插入和删除比较快

list：双向链表，支持双向顺序访问（rbegin()、rend()），在 list 任意位置插入和删除都比较快

forward_list：单向链表，只能单向顺序访问，在 forward_list 的任意位置插入和删除都比较快

array：固定大小的数组，支持随机访问，不能添加或者删除元素

string：与 vector 类似，专门保存字符串，随机访问快，在尾部插入和删除快

STL关联容器

map：键值对，一对一，基于红黑树，对关键字进行排序

set：只保存关键字，不重复

multimap：关键字可以重复的 map ，即一对多，如统计数学课的学生成绩

multiset：保存可以重复的关键字

unordered_map：键值对，一对一，基于哈希值，不对键值对进行排序

unordered_set：只保存关键字，不排序

unordered_multimap：键值对，一对多，基于哈希值

unordered_multiset：保存可以重复的关键字，不排序

STL容器适配器

包括：stack、queue、priority_queue

stack 和 queue 基于deque实现， priority_queue 基于 vector 实现

流对象

包括输入流对象（ostream，如std::cin，从键盘读取数据），输出流对象（istream，如std::cout，向屏幕写入数据）

还有文件输入流对象（ifstream，使用 std::ifstream 来创建对象，将数据从文件中读取出来），文件输出流对象（ofstream，使用 std::ofstream 来创建对象，将数据写入文件）

#include <iostream>
#include <fstream>
using namespace std;

void test01()
{
    ofstream file;
    file.open("text.txt", ios::out);

    file << "xinm" << endl;
    file << "namji" << endl;
    file.close();
}
void test02()
{
    ifstream ifile;
    ifile.open("text.txt", ios::in);
    if(ifile.is_open()){
        char buf[1024];
        while(ifile >> buf)
        {
            cout<< buf<<endl;
        }
    }
    ifile.close();
}

int main()
{
    test02();
    return 0;
}

使用二进制流读写文件

#include <iostream>
#include <fstream>
using namespace std;
class Person
{
public:
    // Person(char name[], int age):name_(name), age_(age){}
    char name_[20];
    int age_;
};

void test01()
{
    ofstream file;
    file.open("text.txt", ios::out | ios::binary);
    Person p = {"hhhhh", 18};
    file.write((const char *)&p, sizeof(p));
   
    file.close();
}
void test02()
{
    ifstream ifile;
    ifile.open("text.txt", ios::in | ios::binary);
    if (ifile.is_open())
    {
        // 1
        // char buf[1024];
        // while(ifile >> buf)
        // {
        //     cout<< buf<<endl;
        // }

        // 2
        // char buf[1024];
        // while (ifile.getline(buf, sizeof(buf)))
        // {
        //     cout << buf << endl;
        // }

        // 3
        // string buf;
        // while(getline(ifile, buf)){
        //     cout << buf <<endl;
        // }

        Person p;
        ifile.read((char *)&p, sizeof(p));
        cout << p.name_ << p.age_ << endl;
    }
    ifile.close();
}

int main()
{
    test02();
    return 0;
}

异常处理的构造和析构函数

若在 try 中抛出异常，在转到 catch 前，会对有关对象进行析构

#include <iostream>

using namespace std;

//异常处理的构造和析构函数 
class Student{
	private:
		string name;
		int sno;
	public:
		Student(string name1,int sno1)
		{
			name=name1;
			sno=sno1;
		} 
		~Student()
		{
			cout<<"Destruct Student:"<<sno<<endl;
		}
		void checkSno()
		{
			if(sno==0)
			{
				throw sno;
			}
			else
			{
				cout<<name<<":"<<sno<<endl; 
			}
		}
};

int main()
{
	try
	{
		Student a("pink",1);
		a.checkSno();
		Student b("floyd",0); //构造对象
		b.checkSno();  //抛出异常跳到catch语句块中
	}
	catch(int)
	{
		cout<<"error:sno=0!"<<endl;
	}
	return 0;
}

可以看到上面这段代码的输出结果是先对a、b析构然后再转到catch输出内容。

类模板与继承

要注意继承的时候要加上基类的类型

#include <iostream>

using namespace std;

template<class T>
class Base
{
    public:
    T c;
};

template<class T>
class Deri: public Base<T>
{
    public:
    T a;
};

int main()
{
    Deri<int> d;
    d.a=4;
    d.c=6;
    cout <<d.Base::c<<endl;
    // cout << sizeof(Deri<int>)<<endl;
    return 0;
}

继承时不能被继承的函数

包括：构造函数、拷贝构造函数、析构函数，注意：operator=函数是可以被继承的

#include <iostream>
#include <cstring>
using namespace std;

class A{
public:
	A(){
	}
	A(int price, int weight):price_(price), weight_(weight){
	}
	A& operator=(const A& a){
		cout << "operator=1" << endl;
	}
private:
	int price_;
	int weight_;
};

class B: public A{
public:
	B(int price, int weight):price_(price), weight_(weight){
	}
private:
	int price_;
	int weight_;
};

int main(){
//	A a1(1,0);
//	A a2;
//	a2=a1;
	B b1(10,0),b2(2,0);
	b2=b1;
	return 0;
}

上面说明operator=函数被继承下去了。

静态数据成员的只能在类外初始化

类内定义，类外初始化一次，然后在整个程序运行期间都可以存在

原因

1、静态成员变量存储在静态存储区域内，在编译阶段就为他们分配内存空间，

2、静态成员变量是类级别的，他在所有类实例中是公有的，如果允许在类内部初始化，就可能导致每个实例都有一个独立的副本

3、这样可以避免多次初始化

#include <iostream>
#include <cstdlib>
#include <ctime>
#include <vector>
#include <math.h>
using namespace std;
class Point
{
public:
	Point(int x, int y) : x_(x), y_(y)
	{
	}
	void setX(int val)
	{
		x_ = val;
	}
	void setY(int val)
	{
		y_ = val;
	}
	int getX() const
	{
		return x_;
	}
	int getY() const
	{
		return y_;
	}

private:
	int x_;
	int y_;
};
class Circle
{
public:
	Circle(int x, int y, int r) : center_(x, y), r_(r)
	{
		num_++;
		cout << "Circle number: " << getNum() << endl;
		;
	}
	static int getNum()
	{
		return num_;
	}
	friend double getDistance(const Circle &c1, const Circle &c2);

private:
	static int num_;
	Point center_;
	int r_;
};

int Circle::num_ = 0;
double getDistance(const Circle &c1, const Circle &c2)
{
		double x=double(c2.center_.getX()-c1.center_.getX());
		double y=double(c2.center_.getY()-c1.center_.getY());
		return sqrt(x*x + y*y);
}

void testCircle()
{
	Circle c1(1, 2, 3);
	Circle c2(4, 6, 2);
	cout << getDistance(c1, c2) << endl;
}

int main()
{
	testCircle();
	return 0;
}
SmallMouseAA
关注
专栏目录
C++若干疑难问题分析
06-22
若干关于C++的问题释义，比如C++赋值运算符重载函数不能被派生类继承的真实原因
C++编程精选加疑难详解
12-20
C++编程精选加疑难详解 爱它就下载它 愿君分享
C++ 疑难点1
chanleoo的博客
01-17 258
1.#include不属于C++程序，所以也是末尾不带分号的原因。里边是函数声明，在编译之前先找到头文件里边声明的具体定义的函数放到头文件那里位置，然后参与代码一起编译 2.对于错误；先双击第一个，定位到那句看前后，不懂,查 3.int a=5,int已经集成好类型是整型，初值为5，class Person{}，Person是个自定义类型，Person person1(陈磊，25)，Perso...
C++学习之五、理解C++疑难问题
我和我追逐的梦~~~
11-29 1931
理解C++疑难问题 1．  引用           专业的C++代码都大量使用了引用。C++的引用是另外一个变量的别名。对引用的修改都会改变该引用所指向变量的值。可以把引用看成是一种隐式的指针，它可以免除获取变量地址和对指针解除引用的麻烦。也可以把引用看作是原变量的另一个名字。可以创建独立的引用变量、使用类中的引用数据成员、接受作为传递给函数和方法的参数、从函数和方法返回引用。 （1）.引
C++疑难求解 分类： C/C++ 2015-04-...
weixin_30352191的博客
04-17 86
1、用getline(cin,str)读取一个string类型，程序如下： #include<iostream> #include<string> using namespace std; int main() { int t; cin>>t; string str1,str2; getline(cin,s...
C++ 疑难点2
chanleoo的博客
01-20 184
数据类型就是对象（各种元素，种类繁多呀，它的广泛性，包括地址（目标对象的地址）），像世界中有各种动物一样表示着这个世界。受控，但是对本身无影响，存在性 理解：泥巴比喻int a=5;int是想法，在大脑里想象捏的图像，a是具体的一团泥巴，5是图像放大的大小 运算，信息的交互，新信息的产生 流程，控制着下一秒的走向，本身与其他无关 函数，黑盒子，一小整套包含数据、运算和流程的处理盒子 理解：划...
C++基础疑难点
ZHANGJNWEI的专栏
07-14 213
指向常量的指针不能用于改变其所指对象的值，存放常量对象的地址，只能使用指向常量的指针。 允许令一个指向常量的指针指向一个非常量对象。指向常量的指针仅仅要求不能通过该指针改变对象的值。 指针是对象而引用不是，允许把指针定义为常量。常量指针必须初始化，完成初始化后值（指向的地址）不能改变；将*放在const之前说明指针是一个常量。 从右向左阅读，弄清楚声明的含义。 指针是一个对象，同时可以指向另一个对象，顶层const表示指针本身是常量，底层const表示指针所指对象是一个常量。 用于声明引用的con
数据结构疑难点解答
09-20
### 数据结构疑难点解答 #### 一、结构体与指针的引入原因 在计算机科学中，数据结构是用于组织和管理数据的方式，使得能够高效地执行数据操作。随着程序复杂性的增加，单一数据类型（如整型、浮点型等）已经无法...
C++问题集(问题集锦)
07-25
《C++问题集锦》是针对C++编程语言的一个综合性的参考资料，它包含了广大程序员在学习和使用C++过程中常见的问题和疑难点。这个压缩包中的"okokok_C++ FAQ LITE — Frequently Asked Questions"文件，很可能是一个...
C++程序调试方法详解：单步调试与运行到光标技巧
其次，"运行到光标处"的功能简化了调试过程，当遇到疑难点时，无需等待程序完整运行，只需将光标移动到怀疑的代码位置，然后启动调试，这样能节省时间和精力，提高调试效率。 C语言发展自马丁·里奇和肯·汤普森等...
【C++养成计划】深入数组和字符串（Day8）
不积跬步，无以至千里！
05-12 3500
给小白打造的专属《C++21天养成计划》，一文打通数组、字符串疑难点！
《C++高级编程》之--理解C++疑难问题
roker
12-07 2172
第二部分、理解C++疑难问题本文基址： http://blog.csdn.net/cugxueyu/archive/2007/12/07/1922575.aspx 索引：引用，const，static, extern, typedef, 类型强制转换，作用域，头文件，变长参数列表，预处理宏。 一、引用1、引用   C++引用是另外一个变量的别名（alias）
c++疑难知识点总结目录
pxlsdz的博客
06-30 1108
1.结构体：点击打开链接2.位运算：点击打开链接3. 类与对象（包含引用 new 重载）：点击打开链接4.虚函数与多态性 ：点击打开链接5.未完待续：
C++/VC++编程的疑难问题及解答
雪松软件开发的专栏
12-04 585
我“C++/VC++编程的疑难问题及解答”给出了三个关于C++/VC++编程的问题及其可能的解决方法。这篇文章再给出几个问题，大家多给我提意见啊，有问题可以给我发信啊！标准程序库问题，再谈list的迭代器是否可以随机移动？ 标准程序库问题，vector的resize()和reserve()函数的区别 标准程序库问题，vector的内存重分配问题 动态链接库与静态链接库 标准程序库问题，再谈li
C++——C++11新语法（中）
最新发布
Wangx_wang的博客
11-06 621
介绍了C++11中的引用折叠、可变模板参数、类的新功能、lambda
Type-C PD诱骗取电快充协议芯片 支持PD 5V、9V、12V、15V、20V电压
xcx003的博客
11-02 597
XSP01A是一款专为Type-C接口设计的取电诱骗协议芯片，它它集成了先进的电源管理和协议控制功能，旨在为用户提供高效、安全、稳定的充电体验。该芯片集成USB Power Delivery (PD) 3.0/2.0快充协议，支持从手机充电器/车充等电源上取电给产品供电。支持最大功率100W给设备安全快速供电。综上所述，XSP01A诱骗取电协议芯片以其高效、安全、稳定的充电性能以及广泛的设备兼容性和应用场景，正在逐步改变着我们的充电体验和设备电源管理方式。
杨辉三角——c语言
aqua3535742358的博客
11-05 442
define N 10 //自己定义输出行数。
c++中局部变量和全局变量同名，使用::访问全局变量
weixin_43845922的博客
11-02 298
局部变量可以与全局变量同名，在函数内引用这个变量时，会用到同名的局部变量，而不会用到全局变量。于有些编译器而言，在同一个函数内可以定义多个同名的局部变量，比如在两个循环体内都定义一个同名的局。答：能，局部会屏蔽全局。要用全局变量，需要使用”::”部变量，而那个局部变量的作用域就在那个循环体内。局部变量能否和全局变量重名？
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值