C++ 关于模板之间的继承， 导致的模板子类的成员看不到（cannot
c
c++
~에 대한
~로 이어지다
회원
주형
상속하다
首先， 开门见山， 这个难题的解决办法是用this指针， 或者使用父类配合着scope resolution。 这个问题是我在学习linked list as an ADT , linked list 是含有纯虚函数， 所以是抽象基础类。 然后又linked list 继承出unordered linked list。 注意， 还可以
首先， 开门见山， 这个难题的解决办法是用this指针， 或者使用父类配合着scope resolution。
这个问题是我在学习linked list as an ADT , linked list 是含有纯虚函数， 所以是抽象基础类。 然后又linked list 继承出unordered linked list。 注意， 还可以由linked list 继承出ordered linked list。
言归正传， 出现问题的代码如下：
linkedlist.h 文件如下：
#ifndef H_LinkedListType
#define H_LinkedListType
#include <iostream>
#include <cassert>
using namespace std;
//Definition of the node
template <class type>
struct nodeType
{
Type info;
nodeType<type> *link;
};
template <class type>
class linkedListIterator
{
public:
linkedListIterator();
//Default constructor
//Postcondition: current = NULL;
linkedListIterator(nodeType<type> *ptr);
//Constructor with a parameter.
//Postcondition: current = ptr;
Type operator*();
//Function to overload the dereferencing operator *.
//Postcondition: Returns the info contained in the node.
linkedListIterator<type> operator++();
//Overload the pre-increment operator.
//Postcondition: The iterator is advanced to the next
// node.
bool operator==(const linkedListIterator<type>& right) const;
//Overload the equality operator.
//Postcondition: Returns true if this iterator is equal to
// the iterator specified by right,
// otherwise it returns the value false.
bool operator!=(const linkedListIterator<type>& right) const;
//Overload the not equal to operator.
//Postcondition: Returns true if this iterator is not
// equal to the iterator specified by
// right; otherwise it returns the value
// false.
private:
nodeType<type> *current; //pointer to point to the current
//node in the linked list
};
template <class type>
linkedListIterator<type>::linkedListIterator()
{
current = NULL;
}
template <class type>
linkedListIterator<type>::
linkedListIterator(nodeType<type> *ptr)
{
current = ptr;
}
template <class type>
Type linkedListIterator<type>::operator*()
{
return current->info;
}
template <class type>
linkedListIterator<type> linkedListIterator<type>::operator++()
{
current = current->link;
return *this;
}
template <class type>
bool linkedListIterator<type>::operator==
(const linkedListIterator<type>& right) const
{
return (current == right.current);
}
template <class type>
bool linkedListIterator<type>::operator!=
(const linkedListIterator<type>& right) const
{ return (current != right.current);
}
//***************** class linkedListType ****************
template <class type>
class linkedListType
{
public:
const linkedListType<type>& operator=
(const linkedListType<type>&);
//Overload the assignment operator.
void initializeList();
//Initialize the list to an empty state.
//Postcondition: first = NULL, last = NULL, count = 0;
bool isEmptyList() const;
//Function to determine whether the list is empty.
//Postcondition: Returns true if the list is empty,
// otherwise it returns false.
void print() const;
//Function to output the data contained in each node.
//Postcondition: none
int length() const;
//Function to return the number of nodes in the list.
//Postcondition: The value of count is returned.
void destroyList();
//Function to delete all the nodes from the list.
//Postcondition: first = NULL, last = NULL, count = 0;
Type front() const;
//Function to return the first element of the list.
//Precondition: The list must exist and must not be
// empty.
//Postcondition: If the list is empty, the program
// terminates; otherwise, the first
// element of the list is returned.
Type back() const;
//Function to return the last element of the list.
//Precondition: The list must exist and must not be
// empty.
//Postcondition: If the list is empty, the program
// terminates; otherwise, the last
// element of the list is returned.
virtual bool search(const Type& searchItem) const = 0;
//Function to determine whether searchItem is in the list.
//Postcondition: Returns true if searchItem is in the
// list, otherwise the value false is
// returned.
virtual void insertFirst(const Type& newItem) = 0;
//Function to insert newItem at the beginning of the list.
//Postcondition: first points to the new list, newItem is
// inserted at the beginning of the list,
// last points to the last node in the list,
// and count is incremented by 1.
virtual void insertLast(const Type& newItem) = 0;
//Function to insert newItem at the end of the list.
//Postcondition: first points to the new list, newItem
// is inserted at the end of the list,
// last points to the last node in the list,
// and count is incremented by 1.
virtual void deleteNode(const Type& deleteItem) = 0;
//Function to delete deleteItem from the list.
//Postcondition: If found, the node containing
// deleteItem is deleted from the list.
// first points to the first node, last
// points to the last node of the updated
// list, and count is decremented by 1.
linkedListIterator<type> begin();
//Function to return an iterator at the begining of the
//linked list.
//Postcondition: Returns an iterator such that current is
// set to first.
linkedListIterator<type> end();
//Function to return an iterator one element past the
//last element of the linked list.
//Postcondition: Returns an iterator such that current is
// set to NULL.
linkedListType();
//default constructor
//Initializes the list to an empty state.
//Postcondition: first = NULL, last = NULL, count = 0;
linkedListType(const linkedListType<type>& otherList);
//copy constructor
~linkedListType();
//destructor
//Deletes all the nodes from the list.
//Postcondition: The list object is destroyed.
protected:
int count; //variable to store the number of
//elements in the list
nodeType<type> *first; //pointer to the first node of the list
nodeType<type> *last; //pointer to the last node of the list
private:
void copyList(const linkedListType<type>& otherList);
//Function to make a copy of otherList.
//Postcondition: A copy of otherList is created and
// assigned to this list.
};
template <class type>
bool linkedListType<type>::isEmptyList() const
{
return(first == NULL);
}
template <class type>
linkedListType<type>::linkedListType() //default constructor
{
first = NULL;
last = NULL;
count = 0;
}
template <class type>
void linkedListType<type>::destroyList()
{
nodeType<type> *temp; //pointer to deallocate the memory
//occupied by the node
while (first != NULL) //while there are nodes in the list
{
temp = first; //set temp to the current node
first = first->link; //advance first to the next node
delete temp; //deallocate the memory occupied by temp
}
last = NULL; //initialize last to NULL; first has already
//been set to NULL by the while loop
count = 0;
}
template <class type>
void linkedListType<type>::initializeList()
{
destroyList(); //if the list has any nodes, delete them
}
template <class type>
void linkedListType<type>::print() const
{
nodeType<type> *current; //pointer to traverse the list
current = first; //set current so that it points to
//the first node
while (current != NULL) //while more data to print
{
cout info link;
}
}//end print
template <class type>
int linkedListType<type>::length() const
{
return count;
} //end length
template <class type>
Type linkedListType<type>::front() const
{
assert(first != NULL);
return first->info; //return the info of the first node
}//end front
template <class type>
Type linkedListType<type>::back() const
{
assert(last != NULL);
return last->info; //return the info of the last node
}//end back
template <class type>
linkedListIterator<type> linkedListType<type>::begin()
{
linkedListIterator<type> temp(first);
return temp;
}
template <class type>
linkedListIterator<type> linkedListType<type>::end()
{
linkedListIterator<type> temp(NULL);
return temp;
}
template <class type>
void linkedListType<type>::copyList
(const linkedListType<type>& otherList)
{
nodeType<type> *newNode; //pointer to create a node
nodeType<type> *current; //pointer to traverse the list
if (first != NULL) //if the list is nonempty, make it empty
destroyList();
if (otherList.first == NULL) //otherList is empty
{
first = NULL;
last = NULL;
count = 0;
}
else
{
current = otherList.first; //current points to the
//list to be copied
count = otherList.count;
//copy the first node
first = new nodeType<type>; //create the node
first->info = current->info; //copy the info
first->link = NULL; //set the link field of
//the node to NULL
last = first; //make last point to the
//first node
current = current->link; //make current point to
//the next node
//copy the remaining list
while (current != NULL)
{
newNode = new nodeType<type>; //create a node
newNode->info = current->info; //copy the info
newNode->link = NULL; //set the link of
//newNode to NULL
last->link = newNode; //attach newNode after last
last = newNode; //make last point to
//the actual last node
current = current->link; //make current point
//to the next node
}//end while
}//end else
}//end copyList
template <class type>
linkedListType<type>::~linkedListType() //destructor
{
destroyList();
}//end destructor
template <class type>
linkedListType<type>::linkedListType
(const linkedListType<type>& otherList)
{
first = NULL;
copyList(otherList);
}//end copy constructor
//overload the assignment operator
template <class type>
const linkedListType<type>& linkedListType<type>::operator=
(const linkedListType<type>& otherList)
{
if (this != &otherList) //avoid self-copy
{
copyList(otherList);
}//end else
return *this;
}
#endif
</type></type></type></class></type></type></class></type></class></type></type></type></type></type></type></class></type></type></type></class></type></type></type></class></type></class></type></class></type></class></type></type></class></type></class></type></type></class></type></class></type></class></type></type></type></type></type></type></type></type></class></type></type></class></type></type></class></type></type></class></type></class></type></type></class></type></class></type></type></type></type></type></class></type></class></cassert></iostream>로그인 후 복사
unorderedLinkedList.h文件如下：
#ifndef H_UnorderedLinkedList
#define H_UnorderedLinkedList
#include "linkedList.h"
using namespace std;
template <class type>
class unorderedLinkedList: public linkedListType<type>
{
public:
bool search(const Type& searchItem) const;
//Function to determine whether searchItem is in the list.
//Postcondition: Returns true if searchItem is in the
// list, otherwise the value false is
// returned.
void insertFirst(const Type& newItem);
//Function to insert newItem at the beginning of the list.
//Postcondition: first points to the new list, newItem is
// inserted at the beginning of the list,
// last points to the last node in the
// list, and count is incremented by 1.
void insertLast(const Type& newItem);
//Function to insert newItem at the end of the list.
//Postcondition: first points to the new list, newItem
// is inserted at the end of the list,
// last points to the last node in the
// list, and count is incremented by 1.
void deleteNode(const Type& deleteItem);
//Function to delete deleteItem from the list.
//Postcondition: If found, the node containing
// deleteItem is deleted from the list.
// first points to the first node, last
// points to the last node of the updated
// list, and count is decremented by 1.
};
template <class type>
bool unorderedLinkedList<type>::
search(const Type& searchItem) const
{
nodeType<type> *current; //pointer to traverse the list
bool found = false;
current = first; //set current to point to the first
//node in the list
while (current != NULL && !found) //search the list
if (current->info == searchItem) //searchItem is found
found = true;
else
current = current->link; //make current point to
//the next node
return found;
}//end search
template <class type>
void unorderedLinkedList<type>::insertFirst(const Type& newItem)
{
nodeType<type> *newNode; //pointer to create the new node
newNode = new nodeType<type>; //create the new node
newNode->info = newItem; //store the new item in the node
newNode->link = this -> first; //insert newNode before first
first = newNode; //make first point to the
//actual first node
count++; //increment count
if (last == NULL) //if the list was empty, newNode is also
//the last node in the list
last = newNode;
}//end insertFirst
template <class type>
void unorderedLinkedList<type>::insertLast(const Type& newItem)
{
nodeType<type> *newNode; //pointer to create the new node
newNode = new nodeType<type>; //create the new node
newNode->info = newItem; //store the new item in the node
newNode->link = NULL; //set the link field of newNode
//to NULL
if ( first == NULL) //if the list is empty, newNode is
//both the first and last node
{
first = newNode;
last = newNode;
count++; //increment count
}
else //the list is not empty, insert newNode after last
{
last->link = newNode; //insert newNode after last
last = newNode; //make last point to the actual
//last node in the list
count++; //increment count
}
}//end insertLast
template <class type>
void unorderedLinkedList<type>::deleteNode(const Type& deleteItem)
{
nodeType<type> *current; //pointer to traverse the list
nodeType<type> *trailCurrent; //pointer just before current
bool found;
if (first == NULL) //Case 1; the list is empty.
cout info == deleteItem) //Case 2
{
current = first;
first = first->link;
count--;
if (first == NULL) //the list has only one node
last = NULL;
delete current;
}
else //search the list for the node with the given info
{
found = false;
trailCurrent = first; //set trailCurrent to point
//to the first node
current = first->link; //set current to point to
//the second node
while (current != NULL && !found)
{
if (current->info != deleteItem)
{
trailCurrent = current;
current = current-> link;
}
else
found = true;
}//end while
if (found) //Case 3; if found, delete the node
{
trailCurrent->link = current->link;
this -> count--;
if (last == current) //node to be deleted
//was the last node
last = trailCurrent; //update the value
//of last
delete current; //delete the node from the list
}
else
cout <br>
主程序如下main.cpp：
<pre class="brush:php;toolbar:false">//This program tests various operation of a linked list
//34 62 21 90 66 53 88 24 10 -999
#include <iostream>
#include "unorderedLinkedList.h"
using namespace std;
int main()
{
unorderedLinkedList<int> list1, list2; //Line 1
int num; //Line 2
cout > num; //Line 4
while (num != -999) //Line 5
{
list1.insertLast(num); //Line 6
cin >> num; //Line 7
}
cout > num; //Line 19
cout it; //Line 27
for (it = list1.begin(); it != list1.end();
++it) //Line 28
cout <br>
编译结果error message 如下：
<p><img src="/static/imghw/default1.png" data-src="/inc/test.jsp?url=http%3A%2F%2Fimg.blog.csdn.net%2F20140730194616575%3Fwatermark%2F2%2Ftext%2FaHR0cDovL2Jsb2cuY3Nkbi5uZXQvYTEzMDczNw%3D%3D%2Ffont%2F5a6L5L2T%2Ffontsize%2F400%2Ffill%2FI0JBQkFCMA%3D%3D%2Fdissolve%2F70%2Fgravity%2FSouthEast&refer=http%3A%2F%2Fblog.csdn.net%2Fa130737%2Farticle%2Fdetails%2F38305293" class="lazy" alt="C++ 关于模板之间的继承， 导致的模板子类的成员看不到（cannot" ><br>
</p>
<p><br>
</p>
<p>错误分析： 按照标准看， 上述的错误似乎有点问题。 因为first， last， count 都是父类的成员变量。 存取类型是protected。 我们的子类unorderedLinkedList 类是公开方式（public）继承linkedList。按说子类即unorderedLinkedList 的成员函数（虚函数）当然可以access 父类的protected 成员变量。 但是在这里出错了。 为什么呢？</p>
<p><br>
</p>
<p>原因是我们这里是模板类之间的继承。 如果是正常的普通类之间的继承， 结果一定是没有问题的。 当然access会通过， 编译会okay。 但是这里是模本类之间的继承。</p>
<p>在这里， 我们需要使用this 指针， 也可以使用scope resolution解决模板类之间的继承时变量访问的问题。 下面我们修改unorderedLinkedList.h 如下：</p>
<p>将模板成员函数定义count， first， last 分别用this -> count, this -> first, this -> last（第二中解决办法是换为linkedListType<type>::first, linkedListType<type>::count,linkedListType<type>::last）。 不光如此， 当在子类中调用模板父类的成员函数的时候， 也要使用this 指针或者用scope resotion 解决这个问题。</type></type></type></p>
<p><br>
</p>
<pre class="brush:php;toolbar:false">#ifndef H_UnorderedLinkedList
#define H_UnorderedLinkedList
#include "linkedList.h"
using namespace std;
template <class type>
class unorderedLinkedList: public linkedListType<type>
{
public:
bool search(const Type& searchItem) const;
//Function to determine whether searchItem is in the list.
//Postcondition: Returns true if searchItem is in the
// list, otherwise the value false is
// returned.
void insertFirst(const Type& newItem);
//Function to insert newItem at the beginning of the list.
//Postcondition: first points to the new list, newItem is
// inserted at the beginning of the list,
// last points to the last node in the
// list, and count is incremented by 1.
void insertLast(const Type& newItem);
//Function to insert newItem at the end of the list.
//Postcondition: first points to the new list, newItem
// is inserted at the end of the list,
// last points to the last node in the
// list, and count is incremented by 1.
void deleteNode(const Type& deleteItem);
//Function to delete deleteItem from the list.
//Postcondition: If found, the node containing
// deleteItem is deleted from the list.
// first points to the first node, last
// points to the last node of the updated
// list, and count is decremented by 1.
};
template <class type>
bool unorderedLinkedList<type>::
search(const Type& searchItem) const
{
nodeType<type> *current; //pointer to traverse the list
bool found = false;
current = this -> first; //set current to point to the first
//node in the list
while (current != NULL && !found) //search the list
if (current->info == searchItem) //searchItem is found
found = true;
else
current = current->link; //make current point to
//the next node
return found;
}//end search
template <class type>
void unorderedLinkedList<type>::insertFirst(const Type& newItem)
{
nodeType<type> *newNode; //pointer to create the new node
newNode = new nodeType<type>; //create the new node
newNode->info = newItem; //store the new item in the node
newNode->link = this -> first; //insert newNode before first
this -> first = newNode; //make first point to the
//actual first node
this -> count++; //increment count
if (this -> last == NULL) //if the list was empty, newNode is also
//the last node in the list
this -> last = newNode;
}//end insertFirst
template <class type>
void unorderedLinkedList<type>::insertLast(const Type& newItem)
{
nodeType<type> *newNode; //pointer to create the new node
newNode = new nodeType<type>; //create the new node
newNode->info = newItem; //store the new item in the node
newNode->link = NULL; //set the link field of newNode
//to NULL
if ( this -> first == NULL) //if the list is empty, newNode is
//both the first and last node
{
this -> first = newNode;
this -> last = newNode;
this -> count++; //increment count
}
else //the list is not empty, insert newNode after last
{
this -> last->link = newNode; //insert newNode after last
this -> last = newNode; //make last point to the actual
//last node in the list
this -> count++; //increment count
}
}//end insertLast
template <class type>
void unorderedLinkedList<type>::deleteNode(const Type& deleteItem)
{
nodeType<type> *current; //pointer to traverse the list
nodeType<type> *trailCurrent; //pointer just before current
bool found;
if (this -> first == NULL) //Case 1; the list is empty.
cout first->info == deleteItem) //Case 2
{
current = this -> first;
this -> first = this -> first->link;
this -> count--;
if (this -> first == NULL) //the list has only one node
this -> last = NULL;
delete current;
}
else //search the list for the node with the given info
{
found = false;
trailCurrent = this -> first; //set trailCurrent to point
//to the first node
current = this -> first->link; //set current to point to
//the second node
while (current != NULL && !found)
{
if (current->info != deleteItem)
{
trailCurrent = current;
current = current-> link;
}
else
found = true;
}//end while
if (found) //Case 3; if found, delete the node
{
trailCurrent->link = current->link;
this -> count--;
if (this -> last == current) //node to be deleted
//was the last node
this -> last = trailCurrent; //update the value
//of last
delete current; //delete the node from the list
}
else
cout <br>
编译通过， 运行结果如下：
<p><img src="/static/imghw/default1.png" data-src="/inc/test.jsp?url=http%3A%2F%2Fimg.blog.csdn.net%2F20140730200300296%3Fwatermark%2F2%2Ftext%2FaHR0cDovL2Jsb2cuY3Nkbi5uZXQvYTEzMDczNw%3D%3D%2Ffont%2F5a6L5L2T%2Ffontsize%2F400%2Ffill%2FI0JBQkFCMA%3D%3D%2Fdissolve%2F70%2Fgravity%2FSouthEast&refer=http%3A%2F%2Fblog.csdn.net%2Fa130737%2Farticle%2Fdetails%2F38305293" class="lazy" alt="C++ 关于模板之间的继承， 导致的模板子类的成员看不到（cannot" ><br>
</p>
<p><br>
</p>
<p><br>
</p>
<p>关于这个模板继承， 子类使用父类的成员是使用this， 或者scope resolution， 解释如下：</p>
<p>//To make the code valid either use this->f(), or Base::f(). Using the -fpermissive flag will also<br>
//let the compiler accept the code, by marking all function calls for which no declaration is visible<br>
//at the time of definition of the template for later lookup at instantiation time, as if it were a<br>
//dependent call. We do not recommend using -fpermissive to work around invalid code, and it will also<br>
//only catch cases where functions in base classes are called, not where variables in base classes are<br>
//used (as in the example above).<br>
//<br>
//Note that some compilers (including G++ versions prior to 3.4) get these examples wrong and accept above<br>
//code without an error. Those compilers do not implement two-stage name lookup correctly.<br>
//<br>
</p>
<p><br>
</p>
<p>接下来是我在stack overflow 网站上得到的解答：</p>
<p><img src="/static/imghw/default1.png" data-src="/inc/test.jsp?url=http%3A%2F%2Fimg.blog.csdn.net%2F20140730201910930%3Fwatermark%2F2%2Ftext%2FaHR0cDovL2Jsb2cuY3Nkbi5uZXQvYTEzMDczNw%3D%3D%2Ffont%2F5a6L5L2T%2Ffontsize%2F400%2Ffill%2FI0JBQkFCMA%3D%3D%2Fdissolve%2F70%2Fgravity%2FSouthEast&refer=http%3A%2F%2Fblog.csdn.net%2Fa130737%2Farticle%2Fdetails%2F38305293" class="lazy" alt="C++ 关于模板之间的继承， 导致的模板子类的成员看不到（cannot" ><br>
</p>
</type></type></type></class></type></type></type></class></type></type></type></class></type></type></class></type></class>로그인 후 복사
본 웹사이트의 성명
본 글의 내용은 네티즌들의 자발적인 기여로 작성되었으며, 저작권은 원저작자에게 있습니다. 본 사이트는 이에 상응하는 법적 책임을 지지 않습니다. 표절이나 침해가 의심되는 콘텐츠를 발견한 경우 admin@php.cn으로 문의하세요.
핫 AI 도구
Undresser.AI Undress
사실적인 누드 사진을 만들기 위한 AI 기반 앱
AI Clothes Remover
사진에서 옷을 제거하는 온라인 AI 도구입니다.
Undress AI Tool
무료로 이미지를 벗다
Clothoff.io
AI 옷 제거제
AI Hentai Generator
AI Hentai를 무료로 생성하십시오.
인기 기사
R.E.P.O. 에너지 결정과 그들이하는 일 (노란색 크리스탈)
3 몇 주 전
By 尊渡假赌尊渡假赌尊渡假赌
R.E.P.O. 최고의 그래픽 설정
3 몇 주 전
By 尊渡假赌尊渡假赌尊渡假赌
어 ass 신 크리드 그림자 : 조개 수수께끼 솔루션
2 몇 주 전
By DDD
R.E.P.O. 아무도들을 수없는 경우 오디오를 수정하는 방법
3 몇 주 전
By 尊渡假赌尊渡假赌尊渡假赌
WWE 2K25 : Myrise에서 모든 것을 잠금 해제하는 방법
4 몇 주 전
By 尊渡假赌尊渡假赌尊渡假赌
뜨거운 도구
메모장++7.3.1
사용하기 쉬운 무료 코드 편집기
SublimeText3 중국어 버전
중국어 버전, 사용하기 매우 쉽습니다.
스튜디오 13.0.1 보내기
강력한 PHP 통합 개발 환경
드림위버 CS6
시각적 웹 개발 도구
SublimeText3 Mac 버전
신 수준의 코드 편집 소프트웨어(SublimeText3)
뜨거운 주제
Gmail 이메일의 로그인 입구는 어디에 있나요?
7477
15
7477
15
Cakephp 튜토리얼
1377
52
1377
52
Steam의 계정 이름 형식은 무엇입니까?
77
11
77
11
Win11 활성화 키 영구
49
19
49
19
NYT 연결 힌트와 답변
19
32
19
32
C++에서 전략 디자인 패턴을 구현하는 방법은 무엇입니까?
Jun 06, 2024 pm 04:16 PM
C++에서 전략 패턴을 구현하는 단계는 다음과 같습니다. 전략 인터페이스를 정의하고 실행해야 하는 메서드를 선언합니다. 특정 전략 클래스를 생성하고 각각 인터페이스를 구현하며 다양한 알고리즘을 제공합니다. 컨텍스트 클래스를 사용하여 구체적인 전략 클래스에 대한 참조를 보유하고 이를 통해 작업을 수행합니다.
Docker 환경에서 PECL을 사용하여 확장자를 설치할 때 오류가 발생하는 이유는 무엇입니까? 그것을 해결하는 방법?
Apr 01, 2025 pm 03:06 PM
Docker 환경을 사용할 때 Docker 환경에 Extensions를 설치하기 위해 PECL을 사용하여 오류의 원인 및 솔루션. 종종 일부 두통이 발생합니다 ...
C 현에서 숯의 역할은 무엇입니까?
Apr 03, 2025 pm 03:15 PM
C에서 숯 유형은 문자열에 사용됩니다. 1. 단일 문자를 저장하십시오. 2. 배열을 사용하여 문자열을 나타내고 널 터미네이터로 끝납니다. 3. 문자열 작동 함수를 통해 작동합니다. 4. 키보드에서 문자열을 읽거나 출력하십시오.
C 언어로 멀티 스레딩을 구현하는 4 가지 방법
Apr 03, 2025 pm 03:00 PM
언어의 멀티 스레딩은 프로그램 효율성을 크게 향상시킬 수 있습니다. C 언어에서 멀티 스레딩을 구현하는 4 가지 주요 방법이 있습니다. 독립 프로세스 생성 : 여러 독립적으로 실행되는 프로세스 생성, 각 프로세스에는 자체 메모리 공간이 있습니다. 의사-다일리트 레딩 : 동일한 메모리 공간을 공유하고 교대로 실행하는 프로세스에서 여러 실행 스트림을 만듭니다. 멀티 스레드 라이브러리 : PTHREADS와 같은 멀티 스레드 라이브러리를 사용하여 스레드를 만들고 관리하여 풍부한 스레드 작동 기능을 제공합니다. COROUTINE : 작업을 작은 하위 작업으로 나누고 차례로 실행하는 가벼운 다중 스레드 구현.
C-Subscript를 계산하는 방법 3 첨자 5 C-Subscript 3 첨자 5 알고리즘 튜토리얼
Apr 03, 2025 pm 10:33 PM
C35의 계산은 본질적으로 조합 수학이며, 5 개의 요소 중 3 개 중에서 선택된 조합 수를 나타냅니다. 계산 공식은 C53 = 5입니다! / (3! * 2!)는 효율을 향상시키고 오버플로를 피하기 위해 루프에 의해 직접 계산할 수 있습니다. 또한 확률 통계, 암호화, 알고리즘 설계 등의 필드에서 많은 문제를 해결하는 데 조합의 특성을 이해하고 효율적인 계산 방법을 마스터하는 데 중요합니다.
c
Apr 04, 2025 am 07:54 AM
C의 Release_Semaphore 함수는 다른 스레드 또는 프로세스가 공유 리소스에 액세스 할 수 있도록 얻은 수피를 해제하는 데 사용됩니다. 세마포어 수를 1 씩 증가시켜 차단 스레드가 계속 실행 될 수 있습니다.
C 언어로 뱀 명칭을 적용하는 방법은 무엇입니까?
Apr 03, 2025 pm 01:03 PM
C 언어에서 뱀 명칭은 코딩 스타일 컨벤션으로 여러 단어를 연결하여 여러 단어를 연결하여 가변 이름 또는 기능 이름을 형성하여 가독성을 향상시킵니다. 편집 및 운영에는 영향을 미치지 않지만 긴 이름 지정, IDE 지원 문제 및 역사적 수하물을 고려해야합니다.
ColorOS15 인터페이스가 공개되었습니다. 이 기기에 대한 큰 변화는 다음과 같습니다.
Aug 28, 2024 pm 03:31 PM
최근 ColorOS15가 내부 베타 테스트를 시작했습니다. 일부 네티즌이 어떻게 진행되는지 살펴보겠습니다. 위 그림에서 볼 수 있듯이 일부 네티즌은 업그레이드 후 OPPO Find X7의 "About This Machine" 인터페이스를 게시했습니다. ColorOS15Beta. 상단 패턴의 큰 변화에 더해, 하단의 구성 정보도 이전 두 열에서 단일 열 수직 분포로 변경되었습니다. 첨부된 내용은 Huawei, Honor, Xiaomi, OPPO, vivo 및 Meizu 등 6개 브랜드의 최신 버전 휴대폰에 대한 "이 휴대폰/휴대폰 정보" 인터페이스입니다. ColorOS 15와 관련하여 어떤 레이아웃이 더 마음에 드는지 알려주세요. 이전 뉴스에 따르면 LivePhoto 라이브 포토를 폭넓게 지원하는 것 외에도 "AirDrop&
