fl <rxjwg98@gmail.com>: Oct 31 09:52AM -0700
Hi,
As I remember that the friendship of a class is not inherited, in the
following code, I don't understand the comment:
// these operators need access to the Query_base* constructor
I do see Query constructor:
Query(const Query &c)
but I do not see Query_base constructor.
BTW, this code snippet is from a C++ book.
Could you tell me how to understand the above comment?
Thanks,
............
class Query_base {
friend class Query;
protected:
typedef TextQuery::line_no line_no;
virtual ~Query_base() { }
private:
// eval returns the |set| of lines that this Query matches
virtual std::set<line_no>
eval(const TextQuery&) const = 0;
// display prints the query
virtual std::ostream&
display(std::ostream& = std::cout) const = 0;
};
// handle class to manage the Query_base inheritance hierarchy
class Query {
// these operators need access to the Query_base* constructor
friend Query operator~(const Query &);
friend Query operator|(const Query&, const Query&);
friend Query operator&(const Query&, const Query&);
public:
Query(const std::string&); // builds a new WordQuery
// copy control to manage pointers and use counting
Query(const Query &c): q(c.q), use(c.use) { ++*use; }
~Query() { decr_use(); }
Query& operator=(const Query&);
// interface functions: will call corresponding Query_base operations
std::set<TextQuery::line_no>
eval(const TextQuery &t) const { return q->eval(t); }
std::ostream &display(std::ostream &os) const
{ return q->display(os); }
|
"Öö Tiib" <ootiib@hot.ee>: Oct 31 01:43PM -0700
On Saturday, 31 October 2015 18:52:55 UTC+2, fl wrote:
> I do see Query constructor:
> Query(const Query &c)
> but I do not see Query_base constructor.
I have feeling that it can be typo in comment. Comment tries
to explain why these operators are made 'friend' of 'Query' but the
given reason is confusing. Most easy to find out why these actually
are made friends is perhaps to make these not friends (remove
friend declarations from class) and try to compile.
> BTW, this code snippet is from a C++ book.
C++ is quite infamous for hundreds of books about it that have low
quality and may mislead more than help.
|
fl <rxjwg98@gmail.com>: Oct 31 01:53PM -0700
On Saturday, October 31, 2015 at 4:43:43 PM UTC-4, Öö Tiib wrote:
> > BTW, this code snippet is from a C++ book.
> C++ is quite infamous for hundreds of books about it that have low
> quality and may mislead more than help.
Thanks.
Yes, I have tried to comment out 'friend' keyword. It cannot pass compiling.
In class Query, there is a private member q, which points to Query_base:
// interface functions: will call corresponding Query_base operations
std::set<TextQuery::line_no>
eval(const TextQuery &t) const
{ return q->eval(t); }
private:
Query(Query_base *query): q(query),
use(new std::size_t(1))
{}
Query_base *q;
I check below a derived class. There is a constructor:
BinaryQuery(Query left, Query right, std::string op)
Is it a derived class constructor?
There is operator (|: or, &: and etc.) on it.
The original code may not comment accurately.
........
class BinaryQuery: public Query_base {
protected:
BinaryQuery(Query left, Query right, std::string op):
lhs(left), rhs(right), oper(op) { }
// abstract class: BinaryQuery doesn't define eval
std::ostream& display(std::ostream &os) const
{ return os << "(" << lhs << " " << oper << " "
<< rhs << ")"; }
const Query lhs, rhs; // right- and left-hand operands
const std::string oper; // name of the operator
};
|
"Öö Tiib" <ootiib@hot.ee>: Oct 31 02:09PM -0700
On Saturday, 31 October 2015 22:53:18 UTC+2, fl wrote:
> Is it a derived class constructor?
> There is operator (|: or, &: and etc.) on it.
> The original code may not comment accurately.
It may be that the comment that you talk about wanted to say something
like: "the operators need access to Query::Query(Query_base*) that is
private and so are made friend.".
|
asetofsymbols@gmail.com: Oct 31 12:38AM -0700
is it possible define operator% as
m<t> operator%(m<t>& a, t (f)(t))
where the 2th arg of operator% is one function
f:t->t?
or
m<t> operator%(m<t> a, t operator f(t))
when the function for apply in one
unary operator f:t->t
|
asetofsymbols@gmail.com: Oct 31 12:51AM -0700
is it all ok in
a=b*c+k
where
m<t> a,b,c,k;
m<t> operator+(const m<t>& x, const m<t>& y)
{m<t> result;
....
return result;
}
m<t> operator*(const m<t>& x, const m<t>& y)
{m<t> result;
....
return result;
}
if one consider memory allocation
Thank you
|
asetofsymbols@gmail.com: Oct 31 01:57AM -0700
> m<t> operator%(m<t> a, t operator f(t))
> when the function for apply in one
> unary operator f:t->t
is possible one operator% as this
<template Q> m<Q> operator%(m<t> a, Q operator f(t))
where f is a function f:t->Q
one operator that has result one matrix
of one other type in template
|
asetofsymbols@gmail.com: Oct 31 03:14AM -0700
Above i mean
template <class q>
m<q> operator%(m<t> x, q (f)(t) )
Where f is a function t->q
In practice
get one matrix of element type t [x]
Create a matrix of element type q
has the same number elements
Matrix x and the same sizes
Apply to each element of x
f and fill the matrix result
Is possible in that way?
y=x%f
|
asetofsymbols@gmail.com: Oct 31 03:54AM -0700
template <class q>
m<q> operator%(m<t> x, q (f)(t) )
If f is one operator for me that
is not possible in C++
m<u32> y(2,3), x(2,3);
y=x%~;
Seem ugly
possibly better
y=~%x;
template <class q>
m<q> operator%( q (f)(t), m<t> a)
with f operator or function...
but in the case of operator
=~%
sound strange...
|
Paavo Helde <myfirstname@osa.pri.ee>: Oct 31 11:47AM -0500
asetofsymbols@gmail.com wrote in news:593ee2f2-a0cb-44c4-9778-
> f and fill the matrix result
> Is possible in that way?
> y=x%f
Yes this is possible (ssuming I have interpreted your mumbling
correctly):
#include <vector>
#include <cassert>
#include <cstdlib>
template<typename T>
std::vector<T> operator%(const std::vector<T>& v, T (*f)(T)) {
std::vector<T> result;
for(auto x: v) result.push_back((*f)(x));
return result;
}
int main() {
std::vector<int> v = {1, -2, 3, -4};
std::vector<int> w = v % std::abs;
assert(w[3]==4);
}
|
asetofsymbols@gmail.com: Oct 31 10:20AM -0700
Thank you
I wrote until now only something as
u32 f(u32 x){return 2*x;}
M<u32> x(2,3);
x.i(); x.apply(f);
|
asetofsymbols@gmail.com: Oct 31 11:18AM -0700
I wrote:
u32 f(u32 x){return 2*x;}
M<u32> x(2,3);
x.i(); x.apply(f);
-------
I have seen in matlab anonymous
functions something as
x.apply( @(z) 2*z);
are there anonymous function in C++?
|
Wouter van Ooijen <wouter@voti.nl>: Oct 31 10:04PM +0100
> functions something as
> x.apply( @(z) 2*z);
> are there anonymous function in C++?
google "c++ lambda"
Wouter
|
Paul <pepstein5@gmail.com>: Oct 31 01:46PM -0700
The code pasted below is a fairly standard implementation of a fairly standard problem -- finding the mth-to-last value in a linked list. I omitted the memory management aspects.
I don't understand why the destructor is never called. For example, a local copy of the linked list is created in the constructList() function. I thought the destructor would be called when it goes out of scope.
Thank you very much for your help.
Paul
#include <cmath>
#include <cstdio>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;
struct linkedList
{
int val;
linkedList* next;
linkedList(int Val):val(Val), next(0)
{
}
~linkedList()
{
cout << "destructor called"; // This never executes.
}
};
// Construct a linked list from stdin
const linkedList* constructList( )
{
linkedList* headList;
linkedList* buildList;
int listItems;
bool first = true;
while(cin >> listItems)
{
if(first)
{
buildList = new linkedList(listItems);
headList = buildList;
first = false;
}
else
{
buildList->next = new linkedList(listItems);
buildList = buildList->next;
}
}
return headList;
}
void mth_to_last(const linkedList* const& list, int m)
{
if(m <= 0)
{
cout << "NIL";
return;
}
const linkedList* fast = list;
const linkedList* slow = list;
for(int i = 0; i < m; ++i)
{
if(fast)
fast = fast->next;
else
{
cout << "NIL";
return;
}
}
while(fast)
{
fast = fast->next;
slow = slow->next;
}
cout << slow->val;
}
int main() {
int m;
cin >> m;
cin.clear();
const linkedList* list = constructList();
mth_to_last(list, m);
return 0;
}
|
bartekltg <bartekltg@gmail.com>: Oct 31 10:01PM +0100
On 31.10.2015 21:46, Paul wrote:
> list is created in the constructList() function. I thought the
> destructor would be called when it goes out of scope.
> Thank you very much for your help.
Dynamically allocated object do not have a scope!
A pointer to linkedList does have a scope, but is is not
tidied to life of an objetc.
If you want to create a dynamic allocated object which life
is equal to the life of a pointer to this object, use smart
pointers. unique_ptr or shared_ptr (and then look to the
manual to see, how to construct pointers,; avoid new).
If you allocate something with new, you (in most cases)
have to delete is manually!
BTW, do not keep linked list as a pointer. You want to
wrap it into an object, a container. Then your container
have a destructor, where you can manually clean everything.
bartekltg
|
fl <rxjwg98@gmail.com>: Oct 31 08:09AM -0700
Hi,
I notice that the return value 'ret_lines' definition has no scope 'TextQuery'
as the internal variable 'has_val'. Is there any rule on such usage?
Thanks,
..........
// returns lines not in its operand's result set
set<TextQuery::line_no>
NotQuery::eval(const TextQuery& file) const
{
// virtual call through the Query handle to eval
set<TextQuery::line_no> has_val = query.eval(file);
set<line_no> ret_lines;
// for each line in the input file, check whether that line is in has_val
// if not, add that line number to ret_lines
for (TextQuery::line_no n = 0; n != file.size(); ++n)
if (has_val.find(n) == has_val.end())
ret_lines.insert(n);
return ret_lines;
}
|
"Öö Tiib" <ootiib@hot.ee>: Oct 31 08:51AM -0700
On Saturday, 31 October 2015 17:09:20 UTC+2, fl wrote:
> I notice that the return value 'ret_lines' definition has no scope 'TextQuery'
> as the internal variable 'has_val'. Is there any rule on such usage?
> Thanks,
You posted a slice of code that does not compile with C++ compiler
and what it means depends on code that you did not post.
We do not know what type names 'line_no' and 'TextQuery::line_no'
represent; seems these are aliases to some integer type.
|
Paavo Helde <myfirstname@osa.pri.ee>: Oct 31 11:31AM -0500
fl <rxjwg98@gmail.com> wrote in
> // virtual call through the Query handle to eval
> set<TextQuery::line_no> has_val = query.eval(file);
> set<line_no> ret_lines;
As far as we know from this excerpt, the names TextQuery::line_no and
line_no may refer to different types, or they may not. For example, if
TextQuery is a class and NotQuery is inherited from TextQuery, they would
most probably refer to the same type.
A decent programming IDE would provide you with a 'go to definition'
feature which would help you to see (with some confidence) if they are
the same or not.
hth
Paavo
|
fl <rxjwg98@gmail.com>: Oct 31 09:58AM -0700
On Saturday, October 31, 2015 at 12:32:19 PM UTC-4, Paavo Helde wrote:
> the same or not.
> hth
> Paavo
Thanks both of you. Both types have its respective typedef's. They are
different.
|
"Alf P. Steinbach" <alf.p.steinbach+usenet@gmail.com>: Oct 31 01:10PM +0100
On 10/31/2015 11:59 AM, Stefan Ram wrote:
> #include <iostream>
> #include <ostream>
> int main() { constexpr auto num{ 11 }; ::std::cout << num << '\n'; }
My gut feeling: None of these involve initializer_list, even though
they syntactically involve initializer-list (oh, the difference of a
hyphen: reminds me of Latin 1 versus Latin-1, not sure what that was).
They look like formally direct initializations.
And as far as I can recall the syntax
int x = {42};
(copy initialization, but with the braces so that it looks like an
initialization_list) has always been valid, from original C and onward.
So, my gut feeling is that you need something like
auto x = {42};
and then you'd be in initializer_list-land.
Cheers & hth.,
- Alf
|
Victor Bazarov <v.bazarov@comcast.invalid>: Oct 31 08:44AM -0400
On 10/31/2015 6:59 AM, Stefan Ram wrote:
> #include <iostream>
> #include <ostream>
> int main() { constexpr auto num{ 11 }; ::std::cout << num << '\n'; }
How do you know that the header <initializer_list> is NOT included by
some directive in <iostream>, <ostream> or any headers they include? If
it's included, it's not "implicit use", is it?
V
--
I do not respond to top-posted replies, please don't ask
|
