C++小例子——04 列向量模板类ColVector

最新推荐文章于 2025-04-08 18:24:21 发布
最新推荐文章于 2025-04-08 18:24:21 发布
阅读量544 收藏 2
点赞数
分类专栏： C++小例子 文章标签： 列向量 模板类 友元函数 运算符重载 实例化
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/meiguanhua/article/details/108325428
版权
本文介绍了如何将C++的列向量类改造成模板类，允许元素类型多样化，如vector和tensor。通过在头文件中声明模板类的实例化，实现了头文件和cpp文件的分离编译。提供了ColVector.h、ColVector.cpp和main.cpp的代码示例，并通过测试验证了所有功能的正确性。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

把03列向量类改成了模板类，如此一来，列向量的元素类型不再局限于double，而可以是vector，tensor等。对于模板类而言，要想实现头文件和cpp文件的分开编译处理，头文件中需要对模板类进行实例化的声明。

写好的代码如下：

ColVector.h头文件

// 2020-07-30
// class ColVector -- head file
// A column vector template class
// type could be double, vector, tensor, etc
// Author: Guanhua Mei

#ifndef ColVector_H
#define ColVector_H

#include <iostream>
#include "Vector.h"

template<class T>
class ColVector
{
private:
	unsigned int m_nSize;	// capicity of column vector, number of elems
	T* m_pColVct;			// column vector array pointer
public:
	// constructors
	// construct with size and value
	ColVector(unsigned int = 0, T = T());

	// copy constructor, deep copy
	ColVector(const ColVector<T>&);

	// copy assignment, deep copy
	ColVector& operator=(const ColVector<T>&);

	// move constructor, shallow copy
	ColVector(ColVector<T>&&) noexcept;

	// move assignment, shallow copy
	ColVector& operator=(ColVector<T>&&) noexcept;

	// destructor
	~ColVector();

	// return size
	unsigned int size() const { return m_nSize; }

	// get value at idx
	T getCompIdx(unsigned int) const;

	// set value at idx
	void setCompIdx(unsigned int, const T& = T());

	// set all
	void setAll(const T& = T());

	// operator [] to fetch value
	T& operator[](unsigned int);
	const T& operator[](unsigned int) const;

	// operator += -= *= /=, legality wil not be checked!!
	ColVector& operator+=(const ColVector&);
	ColVector& operator+=(const T&);
	ColVector& operator-=(const ColVector&);
	ColVector& operator-=(const T&);
	ColVector& operator*=(const ColVector&);
	ColVector& operator*=(const T&);
	ColVector& operator/=(const ColVector&);
	ColVector& operator/=(const T&);

	// friend operator + - * /, legality wil not be checked!!
	template<class Type>
	friend ColVector<Type> operator+(const ColVector<Type>&, const ColVector<Type>&);
	template<class Type>
	friend ColVector<Type> operator+(const ColVector<Type>&, const Type&);
	template<class Type>
	friend ColVector<Type> operator+(const Type&, const ColVector<Type>&);
	template<class Type>
	friend ColVector<Type> operator-(const ColVector<Type>&, const ColVector<Type>&);
	template<class Type>
	friend ColVector<Type> operator-(const ColVector<Type>&, const Type&);
	template<class Type>
	friend ColVector<Type> operator-(const Type&, const ColVector<Type>&);
	template<class Type>
	friend ColVector<Type> operator*(const ColVector<Type>&, const ColVector<Type>&);
	template<class Type>
	friend ColVector<Type> operator*(const ColVector<Type>&, const Type&);
	template<class Type>
	friend ColVector<Type> operator*(const Type&, const ColVector<Type>&);
	template<class Type>
	friend ColVector<Type> operator/(const ColVector<Type>&, const ColVector<Type>&);
	template<class Type>
	friend ColVector<Type> operator/(const ColVector<Type>&, const Type&);
	template<class Type>
	friend ColVector<Type> operator/(const Type&, const ColVector<Type>&);

	// print
	void print();

	// outputstream operator <<
	template<class Type>
	friend std::ostream& operator<<(std::ostream&, const ColVector<Type>&);
};

// instantiation template class
template class ColVector<double>;
template class ColVector<Vector>;

// instantiation template friend functions
// instantiation of operator <<
template std::ostream& operator<<(std::ostream&, const ColVector<double>&);
template std::ostream& operator<<(std::ostream&, const ColVector<Vector>&);

// friend functions need to be declarated outside again!
// friend function of outputstream operator <<
template<class T>
std::ostream& operator<<(std::ostream&, const ColVector<T>&);

// friend functions of operator + - * /, legality wil not be checked!!
template<class Type>
ColVector<Type> operator+(const ColVector<Type>&, const ColVector<Type>&);
template<class Type>
ColVector<Type> operator+(const ColVector<Type>&, const Type&);
template<class Type>
ColVector<Type> operator+(const Type&, const ColVector<Type>&);
template<class Type>
ColVector<Type> operator-(const ColVector<Type>&, const ColVector<Type>&);
template<class Type>
ColVector<Type> operator-(const ColVector<Type>&, const Type&);
template<class Type>
ColVector<Type> operator-(const Type&, const ColVector<Type>&);
template<class Type>
ColVector<Type> operator*(const ColVector<Type>&, const ColVector<Type>&);
template<class Type>
ColVector<Type> operator*(const ColVector<Type>&, const Type&);
template<class Type>
ColVector<Type> operator*(const Type&, const ColVector<Type>&);
template<class Type>
ColVector<Type> operator/(const ColVector<Type>&, const ColVector<Type>&);
template<class Type>
ColVector<Type> operator/(const ColVector<Type>&, const Type&);
template<class Type>
ColVector<Type> operator/(const Type&, const ColVector<Type>&);

// instantiation of operator + - * /
template ColVector<double> operator+(const ColVector<double>&, const ColVector<double>&);
template ColVector<double> operator+(const ColVector<double>&, const double&);
template ColVector<double> operator+(const double&, const ColVector<double>&);
template ColVector<double> operator-(const ColVector<double>&, const ColVector<double>&);
template ColVector<double> operator-(const ColVector<double>&, const double&);
template ColVector<double> operator-(const double&, const ColVector<double>&);
template ColVector<double> operator*(const ColVector<double>&, const ColVector<double>&);
template ColVector<double> operator*(const ColVector<double>&, const double&);
template ColVector<double> operator*(const double&, const ColVector<double>&);
template ColVector<double> operator/(const ColVector<double>&, const ColVector<double>&);
template ColVector<double> operator/(const ColVector<double>&, const double&);
template ColVector<double> operator/(const double&, const ColVector<double>&);

template ColVector<Vector> operator+(const ColVector<Vector>&, const ColVector<Vector>&);
template ColVector<Vector> operator+(const ColVector<Vector>&, const Vector&);
template ColVector<Vector> operator+(const Vector&, const ColVector<Vector>&);
template ColVector<Vector> operator-(const ColVector<Vector>&, const ColVector<Vector>&);
template ColVector<Vector> operator-(const ColVector<Vector>&, const Vector&);
template ColVector<Vector> operator-(const Vector&, const ColVector<Vector>&);
template ColVector<Vector> operator*(const ColVector<Vector>&, const ColVector<Vector>&);
template ColVector<Vector> operator*(const ColVector<Vector>&, const Vector&);
template ColVector<Vector> operator*(const Vector&, const ColVector<Vector>&);
template ColVector<Vector> operator/(const ColVector<Vector>&, const ColVector<Vector>&);
template ColVector<Vector> operator/(const ColVector<Vector>&, const Vector&);
template ColVector<Vector> operator/(const Vector&, const ColVector<Vector>&);

// dot product, legality wil not be checked!!
double dotProduct(const ColVector<double>&, const ColVector<double>&);

// magnitude, i.e., 2nd norm
double norm(const ColVector<double>&);

// unit
ColVector<double> unit(const ColVector<double>&);


#endif

ColVector.cpp文件

// 2020-07-30
// class ColVector -- cpp file
#include "ColVector.h"

// constructors
// construct with size and value
template<class T>
ColVector<T>::ColVector(unsigned int nSize, T tVal) :
	m_nSize(nSize), m_pColVct(nullptr)
{
	//std::cout << "Construct by size and value. " << std::endl;
	if (m_nSize > 0)	// ask memory
		m_pColVct = new T[m_nSize];
	for (unsigned int i = 0; i < m_nSize; ++i)	// assign values
		m_pColVct[i] = tVal;
}

// copy constructor, deep copy
template<class T>
ColVector<T>::ColVector(const ColVector<T>& colVct)
{
	//std::cout << "Copy constructor. " << std::endl;
	m_nSize = colVct.m_nSize;
	m_pColVct = nullptr;
	if (m_nSize > 0)	// ask memory
		m_pColVct = new T[m_nSize];
	for (unsigned int i = 0; i < m_nSize; ++i)	// assign values
		m_pColVct[i] = colVct.m_pColVct[i];
}

// copy assignment, deep copy
template<class T>
ColVector<T>& ColVector<T>::operator=(const ColVector<T>& colVct)
{
	//std::cout << "Copy assignment. " << std::endl;
	if (this == &colVct)
		return *this;
	if (m_pColVct != nullptr)	// free old memory
		delete[] m_pColVct;
	m_pColVct = nullptr;
	m_nSize = colVct.m_nSize;
	if (m_nSize > 0)	// ask new memory
		m_pColVct = new T[m_nSize];
	for (unsigned i = 0; i < m_nSize; ++i)	// assign values
		m_pColVct[i] = colVct.m_pColVct[i];
	return *this;
}

// move constructor, shallow copy while keep memory
template<class T>
ColVector<T>::ColVector(ColVector<T>&& colVctRhs) noexcept:
	m_nSize(colVctRhs.m_nSize), m_pColVct(colVctRhs.m_pColVct)
{
	//std::cout << "move constructor" << std::endl;
	colVctRhs.m_nSize = 0;
	// Set rhs value ptr to nullptr, to keep its memory in destructor
	colVctRhs.m_pColVct = nullptr;
}

// move assignment, shallow copy while keep memory
template<class T>
ColVector<T>& ColVector<T>::operator=(ColVector<T>&& colVctRhs) noexcept
{
	//std::cout << "move assignment. " << std::endl;
	if (this == &colVctRhs)	// prevent self assignment
		return *this;
	// free old memory
	m_nSize = 0;
	if (m_pColVct != nullptr)
		delete[] m_pColVct;
	// assign size and pointer
	m_nSize = colVctRhs.m_nSize;
	m_pColVct = colVctRhs.m_pColVct;
	// set rhs ptr null to keep memory in destructor
	colVctRhs.m_nSize = 0;
	colVctRhs.m_pColVct = nullptr;
	return *this;
}

// destructor
template<class T>
ColVector<T>::~ColVector()
{
	//std::cout << "Destructor. " << *this << std::endl;
	if (m_pColVct != nullptr)	// free memory
		delete[] m_pColVct;
	m_pColVct = nullptr;
	m_nSize = 0;
}

// get value at idx
template<class T>
T ColVector<T>::getCompIdx(unsigned int nIdx) const
{
	if (nIdx < m_nSize)
		return m_pColVct[nIdx];
	else
		return T();
}

// set value at idx
template<class T>
void ColVector<T>::setCompIdx(unsigned int nIdx, const T& tVal)
{
	if (nIdx < m_nSize)
		m_pColVct[nIdx] = tVal;
}

// set all
template<class T>
void ColVector<T>::setAll(const T& tVal)
{
	for (unsigned i = 0; i < m_nSize; ++i)
		m_pColVct[i] = tVal;
}

// operator [] to fetch value
template<class T>
T& ColVector<T>::operator[](unsigned int nIdx)
{
	return m_pColVct[nIdx];	// do not check if nIdx is correct
}

template<class T>
const T& ColVector<T>::operator[](unsigned int nIdx) const
{
	return m_pColVct[nIdx];	// do not check if nIdx is correct
}

// operator += -= *= /=, legality wil not be checked!!
template<class T>
ColVector<T>& ColVector<T>::operator+=(const ColVector<T>& colVct)
{
	for (unsigned int i = 0; i < m_nSize; ++i)
		m_pColVct[i] += colVct.m_pColVct[i];
	return *this;
}

template<class T>
ColVector<T>& ColVector<T>::operator+=(const T& tVal)
{
	for (unsigned int i = 0; i < m_nSize; ++i)
		m_pColVct[i] += tVal;
	return *this;
}

template<class T>
ColVector<T>& ColVector<T>::operator-=(const ColVector<T>& colVct)
{
	for (unsigned int i = 0; i < m_nSize; ++i)
		m_pColVct[i] -= colVct.m_pColVct[i];
	return *this;
}

template<class T>
ColVector<T>& ColVector<T>::operator-=(const T& tVal)
{
	for (unsigned int i = 0; i < m_nSize; ++i)
		m_pColVct[i] -= tVal;
	return *this;
}

template<class T>
ColVector<T>& ColVector<T>::operator*=(const ColVector<T>& colVct)
{
	for (unsigned int i = 0; i < m_nSize; ++i)
		m_pColVct[i] *= colVct.m_pColVct[i];
	return *this;
}

template<class T>
ColVector<T>& ColVector<T>::operator*=(const T& tVal)
{
	for (unsigned int i = 0; i < m_nSize; ++i)
		m_pColVct[i] *= tVal;
	return *this;
}

template<class T>
ColVector<T>& ColVector<T>::operator/=(const ColVector<T>& colVct)
{
	for (unsigned int i = 0; i < m_nSize; ++i)
		m_pColVct[i] /= colVct.m_pColVct[i];
	return *this;
}

template<class T>
ColVector<T>& ColVector<T>::operator/=(const T& tVal)
{
	for (unsigned int i = 0; i < m_nSize; ++i)
		m_pColVct[i] /= tVal;
	return *this;
}

// functions of operator + - * /, legality wil not be checked!!
template<class Type>
ColVector<Type> operator+(const ColVector<Type>& lhs, const ColVector<Type>& rhs)
{
	ColVector<Type> colVctTmp = lhs;
	colVctTmp += rhs;
	return colVctTmp;
}

template<class Type>
ColVector<Type> operator+(const ColVector<Type>& lhs, const Type& tVal)
{
	ColVector<Type> colVctTmp(lhs);
	colVctTmp += tVal;
	return colVctTmp;
}

template<class Type>
ColVector<Type> operator+(const Type& tVal, const ColVector<Type>& rhs)
{
	ColVector<Type> colVctTmp(rhs);
	colVctTmp += tVal;
	return colVctTmp;
}

template<class Type>
ColVector<Type> operator-(const ColVector<Type>& lhs, const ColVector<Type>& rhs)
{
	ColVector<Type> colVctTmp = lhs;
	colVctTmp -= rhs;
	return colVctTmp;
}

template<class Type>
ColVector<Type> operator-(const ColVector<Type>& lhs, const Type& tVal)
{
	ColVector<Type> colVctTmp(lhs);
	colVctTmp -= tVal;
	return colVctTmp;
}

template<class Type>
ColVector<Type> operator-(const Type& tVal, const ColVector<Type>& rhs)
{
	ColVector<Type> colVctTmp(rhs.m_nSize, tVal);
	colVctTmp -= rhs;
	return colVctTmp;
}

template<class Type>
ColVector<Type> operator*(const ColVector<Type>& lhs, const ColVector<Type>& rhs)
{
	ColVector<Type> colVctTmp = lhs;
	colVctTmp *= rhs;
	return colVctTmp;
}

template<class Type>
ColVector<Type> operator*(const ColVector<Type>& lhs, const Type& tVal)
{
	ColVector<Type> colVctTmp(lhs);
	colVctTmp *= tVal;
	return colVctTmp;
}

template<class Type>
ColVector<Type> operator*(const Type& tVal, const ColVector<Type>& rhs)
{
	ColVector<Type> colVctTmp(rhs);
	colVctTmp *= tVal;
	return colVctTmp;
}

template<class Type>
ColVector<Type> operator/(const ColVector<Type>& lhs, const ColVector<Type>& rhs)
{
	ColVector<Type> colVctTmp = lhs;
	colVctTmp /= rhs;
	return colVctTmp;
}

template<class Type>
ColVector<Type> operator/(const ColVector<Type>& lhs, const Type& tVal)
{
	ColVector<Type> colVctTmp(lhs);
	colVctTmp /= tVal;
	return colVctTmp;
}

template<class Type>
ColVector<Type> operator/(const Type& tVal, const ColVector<Type>& rhs)
{
	ColVector<Type> colVctTmp(rhs.m_nSize, tVal);
	colVctTmp /= rhs;
	return colVctTmp;
}

// print
template<class T>
void ColVector<T>::print()
{
	if (m_nSize == 0)
		std::cout << "Empty Column Vector! " << std::endl;
	else
	{
		std::cout << "[";
		for (unsigned int i = 0; i < m_nSize - 1; ++i)
			std::cout << m_pColVct[i] << "; ";
		std::cout << m_pColVct[m_nSize - 1] << "]" << std::endl;
	}
}

// outputstream operator <<
template<class T>
std::ostream& operator<<(std::ostream& os, const ColVector<T>& colVct)
{
	if (colVct.size() == 0)
		os << "Empty Column Vector! ";
	else
	{
		os << "[";
		for (unsigned int i = 0; i < colVct.size() - 1; ++i)
			os << colVct[i] << "; ";
		os << colVct[colVct.size() - 1] << "]";
	}
	return os;
}

// dot product, legality wil not be checked!!
double dotProduct(const ColVector<double>& lhs,
	const ColVector<double>& rhs)
{
	double dVal = 0.0;
	for (unsigned int i = 0; i < lhs.size(); ++i)
		dVal += (lhs[i] * rhs[i]);
	return dVal;
}

// magnitude, i.e., 2nd norm
double norm(const ColVector<double>& colVct)
{
	return sqrt(dotProduct(colVct, colVct));
}

// unit
ColVector<double> unit(const ColVector<double>& colVct)
{
	return (colVct / norm(colVct));
}

测试主函数main.cpp

// 2020-07-30
// Test of colVector template
// Author: Guanhua Mei

#include <iostream>
#include "ColVector.h"
#include "Vector.h"

int main()
{
	ColVector<double> colVct2(5, 1.2);
	ColVector<double> colVct1(colVct2);
	std::cout << colVct1 << std::endl;

	colVct1.setAll(2.3);
	std::cout << colVct1 << std::endl;

	colVct1.setCompIdx(0, 5.4);
	colVct1.setCompIdx(1, 3.2);
	std::cout << colVct1 << std::endl;
	std::cout << colVct1.getCompIdx(1) << std::endl;
	std::cout << colVct1[0] << std::endl;

	std::cout << "-------------------------------------" << std::endl;
	std::cout << "-------- test A += -= *= /= B -------" << std::endl;
	colVct1 += colVct2;
	colVct1.print();

	colVct1 += 3;
	colVct1.print();

	colVct1 -= 3;
	colVct1.print();

	colVct1 -= colVct2;
	colVct1.print();

	colVct1 *= 3;
	colVct1.print();

	colVct1 *= colVct2;
	colVct1.print();

	colVct1 /= colVct2;
	colVct1.print();

	colVct1 /= 3;
	colVct1.print();

	std::cout << "-------------------------------------" << std::endl;
	std::cout << "---------- test A + - * / B ---------" << std::endl;

	std::cout << colVct1 + colVct2 << std::endl;
	std::cout << colVct1 + 10.0 << std::endl;
	std::cout << 10.0 + colVct1 << std::endl;

	std::cout << colVct1 - colVct2 << std::endl;
	std::cout << colVct1 - 10.0 << std::endl;
	std::cout << 10.0 - colVct1 << std::endl;

	std::cout << colVct1 * colVct2 << std::endl;
	std::cout << colVct1 * 10.0 << std::endl;
	std::cout << 10.0 * colVct1 << std::endl;

	std::cout << colVct1 / colVct2 << std::endl;
	std::cout << colVct1 / 10.0 << std::endl;
	std::cout << 10.0 / colVct1 << std::endl;

	std::cout << "-------------------------------------" << std::endl;
	std::cout << "-------- test dot, norm, unit -------" << std::endl;
	std::cout << dotProduct(colVct1, colVct2) << std::endl;
	//std::cout << (5.4+3.2+2.3+2.3+2.3)*1.2 << std::endl;
	std::cout << norm(colVct1) << std::endl;
	std::cout << unit(colVct1) << std::endl;

	// Correct!!

	std::cout << "-------------------------------------" << std::endl;
	std::cout << "----- test of colVector<Vector> -----" << std::endl;
	ColVector<Vector> colVct3(3, Vector(1, 2, 3));
	std::cout << colVct3 << std::endl;
	ColVector<Vector> colVct4(colVct3);
	std::cout << colVct4 << std::endl;

	colVct3.setCompIdx(1, Vector(6, 7, 8)); colVct3.print();
	colVct3.setAll(); colVct3.print();
	colVct3.setCompIdx(0, Vector(1, 2, 3));
	colVct3.setCompIdx(1, Vector(4, 5, 6));
	colVct3.setCompIdx(2, Vector(7, 8, 9));
	colVct3.print();

	colVct4.setCompIdx(0, Vector(3, 1, 4));
	colVct4.setCompIdx(1, Vector(1, 5, 9));
	colVct4.setCompIdx(2, Vector(2, 6, 5));
	colVct4.print();

	colVct3 += colVct3;		colVct3.print();
	colVct3 += Vector(3, 4, 5); colVct3.print();
	colVct3 -= Vector(3, 4, 5); colVct3.print();
	colVct3 -= colVct4;		colVct3.print();	
	colVct3 *= Vector(3, 4, 5); colVct3.print();
	colVct3 *= colVct4;		colVct3.print();
	colVct3 /= Vector(3, 4, 5); colVct3.print();
	colVct3 /= colVct4;		colVct3.print();

	std::cout << colVct3 + colVct4 << std::endl;
	std::cout << colVct3 + Vector(1, 2, 3) << std::endl;

	std::cout << colVct3 - colVct4 << std::endl;
	std::cout << colVct3 - Vector(1, 2, 3) << std::endl;

	std::cout << colVct3 * colVct4 << std::endl;
	std::cout << colVct3 * Vector(1, 2, 3) << std::endl;

	std::cout << colVct3 / colVct4 << std::endl;
	std::cout << colVct3 / Vector(1, 2, 3) << std::endl;

	return 0;
}

测试结果，表明所有函数均实现了其功能。
在这里插入图片描述

Linux域名解析（DNS）
zl965230的博客
04-17 3132
5）、对应的顶级名称服务器在收到DNS查询请求后，也是先查询自己的缓存，如果有所请求的DNS域名的记录项，则相接把对应的记录项返回给本地名称服务器，然后再由本地名称服务器返回给DNS客户端，否则向本地名称服务器返回所请求的DNS域名中的二级域名所对应的二级名称服务器地址。顶级名称服务器在收到DNS查询请求后，先查询自己的缓存，如果有所请求的DNS域名的记录项，则相接把对应的记录项返回给DNS客户端，否则通过查询后把对应域名中二级域名所对应的二级名称服务器地址信息以一条DNS应答报文返回给DNS客户端。
Linux-DNS域名解析服务
qq_42520799的博客
08-18 1642
DNS的定义、域名结构、DNS查找顺序、域名解析的命令工具、域名解析流程、搭建本地DNS服务器、小结、补充等
linux域名解析
weixin_44321116的博客
01-18 1万+
linux域名解析 首先确保你的电脑可以连上网,服务端和客户端能够连通 1.本地解析:优先级高 在服务端中 ping www.baidu.com #找出ip 在客户端中的浏览器中搜索ip地址就可以上网，但是ip地址记起来非常不方便，所以这里用到域名解析 vim /etc/hosts #添加183.232.231 www.baidu.com 此文件中写什么访问什么，没有写的地址就不能访问...
linux DNS域名解析服务
最新发布
2501_91344113的博客
04-08 1351
DNS(域名解析系统)作为互联网基础设施的核心组件，承担着将易记的域名转换为机器可识别的 IP地址的关键任务。其正向解析(域名到 IP)与反向解析(IP 到域名)功能，极大简化了网络资源的访问与管理。通过 BIND，管理员可构建缓存域名服务器以加速査询、主域名服务器以自主管理区域数据，以及从域名服务器实现数据冗余与负载均衡。
【Linux】域名解析
chizizizizizi的博客
04-08 8056
1、 vi /etc/hosts 进入域名解析文件 2 、按i键进入编辑模式 （前面几行不用管） 3 、 添加ip和主机名（中间空格） 如图添加了zjh和zjh2两个域名及其对应的ip地址 4、按sec键退出编辑模式，然后:wq保存并退出 这样ping域名时就可以解析出其ip地址 5、可使用ping命令查看是否解析成功 注意使用ctrl+c停止 这样就说明解析成功 注意:互ping时两台虚拟机都需进行以上操作，且处同一网段 ...
linux------DNS域名解析
STARDEIT的博客
10-06 2931
一、DNS的作用及类型
Linux的DNS域名解析服务
2402_83805984的博客
04-25 1688
DNS域名系统（Domain Name System 缩写为：DNS）是因特网的一项核心服务，它作为可以将域名和IP地址相互映射的一个分布式数据库，能够使人更加方便的访问互联网，而不用去记住能够被机器直接读取的IP数串。DNS服务使用TCP和UDP的53端口TCP的53端口用于连接DNS服务器，UDP的53端口用于解析DNS。每一级域名长度的限制是63个字符，域名总长度则不能超过253个字符。
Linux下实现动态域名解析.pdf
09-06
Linux下实现动态域名解析.pdf
Linux系统进行DNS域名解析
扮瘦人的博客
06-05 1657
DNS概述，内网配置DNS
linux下动态域名解析
08-16
http://blog.youkuaiyun.com/yangzhilq2,见相关文章说明。 扣扣联系：77086540
Linux域名解析
陈国润
10-08 323
先自动获取地址 装bind的服务，后面跟-y，后面不用选y 介绍后面会用到的几个文件 1，/etc/named.conf（主配置文件），用来定义bind服务程序的运行 2，/var/named（数据配置文件），存放正反向解析配置 3，/etc/named.rfc1912.zones（区域配置文件），保存域名和IP地址对应关系所在位置，每个域名对应的每个IP地址所在的具体位置 4...
LINUX下域名解析
zzzAzl的博客
01-14 886
写一个域名解析的demo #include <stdio.h> #include <iostream> #include <netdb.h> #include <sys/socket.h> #include <errno.h> #include <arpa/inet.h> int main() { struct hostent *host; char *p1 = (char *)"vs1.video.ge.chinamobile.c
Linux网络-DNS域名解析服务
F12138X的博客
04-25 1563
青春须早为，岂能长少年
DNS 域名解析服务
yiluo__的博客
05-15 737
文件中的“@”符号表示当前的 DNS 区域名，相当于“bdqn.com.”或 “admin.bdqn.com.”，表示域管理员的电子邮箱地址（由于“@”符号已有其他含义，因此将电 子邮件地址中的“@”用“.”代替）。SOA 记录中的更新序列号用来同步主、从服务器的区域数 据，当从服务器判断区域更新时，若发现主服务器中的序列号与本地区域数据中的序列号相 同，则不会进行下载。例如，若当前的 DNS 域为“bdqn.com”，则在文件中的主机地 址“www”相当于“www.bdqn.com.”。
Linux域名解析（host、nslookup、dig、DNS）
热门推荐
renfeigui0的博客
09-23 2万+
一、查看主机名与IP的对应 二、域名查找工具dig 三、域名解析两种方法DNS和Host 1、hosts文件。 2、 设置DNS 3、Host表解析与DNS解析的次序由文件/etc/host.conf决定，Hosts优先于DNS。
Linux系统域名解析详解与实践
Linux网络域名解析是操作系统中将主机名转换成对应的IP地址的过程。这种解析是通过域名系统（Domain Name System, DNS）来完成的。...通过这些内容，我们可以更深入地理解和掌握Linux环境下域名解析的整个流程。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值